@woosh/meep-engine 2.131.19 → 2.131.21

package/README.md

@@ -1,126 +1,110 @@
 # Meep Engine
+**The unopinionated, high-performance ECS engine for code-first developers.**
 
-## Getting Started
+Meep is a battle-tested JavaScript game engine designed for scale. Built over 10+ years and used in commercial Steam releases, it strips away the bloat of traditional engines to offer a molecular, zero-allocation architecture.
 
-We offer a [minimal project](http://gitlab.company-named.com/travnik/dream-engine-template) with no bells or whistles, just enough to run the engine and get you starter. If you're starting from scratch this is likely the best option.
+It is designed for engineers who want full control, offering performance that rivals native code on the web.
 
-## Documentation
+[🚀 Quick Start Template](http://gitlab.company-named.com/travnik/dream-engine-template) | [📚 Documentation](http://meep-engine.company-named.com:8080/docs/getting_started/Installation)
 
-[Engine Documentation](http://meep-engine.company-named.com:8080/docs/getting_started/Installation)
+---
+
+## Why Meep?
+Most web engines are heavy, opinionated, and struggle with garbage collection. Meep is different.
+
+* **Pure ECS Architecture:** A true data-oriented foundation that supports complex hierarchies and millions of entities. Unlike hybrid engines, our component queries are instantaneous.
+* **Molecular Modularity:** Distributed as ~3,000 fine-grained modules. Need a lerp function? Import it for a 4-line footprint. You never pay for code you don't use.
+* **Zero-Garbage Architecture:** Custom memory management ensures stable frame rates. Meep handles millions of objects on low-spec mobile hardware without GC spikes.
+* **Code-First:** No GUI. No black boxes. Meep is a programmatic tool designed for software engineers who value architecture and long-term integration.
+* **Battle-Hardened:** Covered by 3,000+ unit tests and extensive assertions. This is not a prototype; it is industrial-grade software.
+
+---
+
+## 💎 Architecture: Pure ECS
+Meep is not yet another Object-Oriented engine with an ECS tacked on; it is a **Pure Entity Component System** engine.
+
+While other engines (like Unity) struggle with slow query times and documentation that advises you to use component lookups "sparingly" — Meep thrives on them.
+
+* **Strict Data-Oriented Design:** One component instance per type per entity. This guarantees memory layout optimization and cache locality.
+* **The Hierarchy Problem: Solved.**  Pure ECS architectures historically struggle with scene graphs and parent-child transforms. Meep solves this natively. You get the composability of a scene graph with the raw speed of a flat array. (Similar to the Rust-based Bevy engine).
+* **Tiered API Access:**
+  * **High-Level:** Use convenient abstraction layers for gameplay logic.
+  * **Low-Level:** Drop down to raw typed arrays for performance-critical paths.
+* **Uncompromised Speed:** Because the architecture is solid, you can query, filter, and iterate over millions of entities without performance cliffs.
+
+---
+
+## ⚡ High-Performance Rendering
+Meep implements a Clustered Forward+ rendering pipeline, allowing for scenes that traditional web engines choke on.
+
+* **Unlimited Lighting:** Render thousands of point lights (muzzle flashes, explosions, torches) with clustered lighting.
+
+* **GPU-Driven Decals:** Handle 1,000,000+ decals for persistent battle damage and environmental details.
+
+* **Massive Terrain:** Chunk-based, auto-culled terrain system supporting up to 256 layers (vs Unity's 4).
 
-## Samples
-To help get you started, various samples are provided under `/samples` folder. Feel free to use them as a point of reference.
+* **"Particular" Particle Engine:** A zero-allocation particle system with full lighting, soft particles, and automatic atlassing. Compiled into just 4 shaders to eliminate state-switching overhead.
 
-## Quality
+* **Path Tracing:** Includes a pure JS path tracer utilizing the engine's internal BVH.
 
-### Testing
-Meep is covered by 2,944 handwritten unit tests, reaching 90%+ coverage in `core` and 40%+ coverage total.
+## 🧠 AI & Simulation Tools
+Meep provides a suite of tools rarely found in JS engines, optimized for complex decision making.
 
-The aim is to [ensure quality](https://about.codecov.io/blog/the-case-against-100-code-coverage/). As a result, the tests are written to cover complex code first and to exhaustively validate critical algorithms.
-Most of the test code is significantly larger than the code that is being tested.
+* **Behavior Trees & Blackboards:** Industry-standard tools for state management.
 
-### Assertions
-Meep is covered by 3,968 asserts. [Assertions](https://en.wikipedia.org/wiki/Assertion_(software_development)) provide very extensive pre- and post-condition checks throughout the engine.
-Asserts are intended primarily for development builds.
-To remove asserts in Vite builds, you can use `@rollup/plugin-strip` package like so:
+* **Monte-Carlo Tree Search:** The same algorithm used in AlphaGo, available for your decision logic.
+
+* **Resource Allocation Solver:** Plan optimal actions based on limited resources (ammo, health, currency).
+
+* **Spatial Query System:** Highly optimized BVH for Ray, Box, Frustum, and Point queries.
+
+* **Inverse Kinematics:** Includes FABRIK solvers and specialized bip/quadruped solvers for uneven terrain adaptation.
+
+## 🛠️ Developer Experience
+
+### Installation & Stripping
+
+Meep is designed to be invisible in production.
+```shell
+npm install @woosh/meep-engine
+```
+
+**Development Mode:** The engine includes ~4,000 assertions to help you catch errors instantly.
+
+**Production Mode:** Using @rollup/plugin-strip, Meep compiles to tiny size and runs at the speed of light.
 
 ```js
+// vite.config.js
 import strip from '@rollup/plugin-strip';
-import { defineConfig } from 'vite';
-
 export default defineConfig({
-    plugins: [{
-        // this will remove all assert statements from the production build
-        ...strip(),
-        apply: 'build'
-    }],
-    // ... the rest of the config ...
+    plugins: [{ ...strip(), apply: 'build' }]
 });
 ```
 
-Assertion package can be found under `/src/core/assert.js`.
-
-## Package Size
+### Reliability
+* **Tests:** 2,944 handwritten tests covering critical algorithms and complex edge cases.
 
-Meep is infinitely tree-shakable, you only package what you use.
+* **Coverage:** 90%+ core coverage.
 
-Meep is distributed as a fine-grained set of ~3,000 modules, with an average module being ~70 lines of code. 
-If you use meep in your project, you add as much or as little to your overall bundle size as you want.
+* **Stability:** Exhaustively tested corner cases over a decade of development.
 
-For example, if you include `core/math/lerp` function, you only add 4 lines of code to your project.
-
-## Performance
+---
 
-Some say that JavaScript is not a viable choice when performance is a factor. I disagree. Meep aims to strike a balance between performance and comfort. 
-That said, meep is performance-first engine. Various API wrappers are offered for convenience, but you're always welcome to drop down to low-level API. 
-Meep is written to generate close to 0 garbage and where that would be otherwise impossible - Meep implements custom memory management to make it possible.
-The engine is built to handle millions of objects at the same time on even low-spec mobile hardware. 
+## Additional Features
 
-## Features
+| Category         | Features                                                                                                              |
+|------------------|-----------------------------------------------------------------------------------------------------------------------|
+| Audio            | Custom culling and attenuation; supports 1,000s of positional sources with zero overhead                              |
+| Input            | Unified abstraction for Touch, Mouse, and Keyboard. Event-driven and Query-based APIs                                 |
+| Assets           | Web-first asset streaming. The engine runs before assets even load                                                    |
+| Serialization    | Binary serialization system with version upgrading                                                                    |
+| UI               | High-speed, zero-garbage UI system. Optional—can be replaced with React/Vue if desired                                |
+| Color Management | Scientific-grade color management toolkit, including spectral-integration tools and modern color spaces such as OKLab |
+| NodeGraph        | A building block for node-graph systems, such as shader editors and workflow engines                                  | 
+| Achievements     | State-of-the-art achievement system, using expressions and blackboards                                                |
+| Inverse Kinematics (IK) | Highly optimized FABRIK inverse kinematics solver even the most complex IK use cases                                  |
 
 ---
-## Input
-* Touch / Mouse / Keyboard device support
-* Unified abstraction of input, offering both query and event-driven APIs
-* Input binding implementation via `InputController` component
-
-## Rendering & Lighting
-### Automatic instancing
-This will minimize the number of draw calls and improve performance.
-### Clustered lighting, aka Forward+
-Meep implements clustered lighting technique which allows you to have a pretty much an unlimited number of point lights in your scene. All the other light types are supported as well, but only point lights are clustered for now. Point lights are useful for various effects, like muzzle flashes, grenade explosions, torches, etc.
-### Terrain
-The terrain engine is chunk-based, which means that terrain is split into rectangular pieces internally, and they are built on-the-fly inside a web-worker based on camera position. Terrain is automatically culled based on camera position, so you're only drawing the chunks that are in view. Terrain supports layers just like Unity, but unlike Unity - Meep supports up to 256 layers of terrain instead of 4.
-### Path tracer
-Pure JS implementation of a path tracer, using engine's BVH (See Physics section)  
-
-## Visual Effects
-### Decals
-Decals in meep are done on the GPU, and as a result you can have a lot of them in your scene. The most I tested in a single scene is 1,000,000 which works quite well. Decals are useful for bullet holes, blood splatter and various scene decorations such as signs and scuff marks.
-### Particles
-Meep's particle engine ("Particular") is optimized for game development needs, this means supporting complex effects and being able to spawn/destroy many particle systems every frame. There are a lot of particle engines out there, but they tend to have costly spawning routines, take up a lot of draw calls and not manage memory well, which leads to pretty poor performance in games. My particle engine supports full particle lighting as well, and soft particles. On top of that - all particles are automatically atlassed in the background and are compiled with just 4 shaders. This means that no matter how many particle effects you have - there will be no shader switching and no texture switching, and there will be no delays associated with shader compilation. Particles are culled, so particle systems that are off-screen are not rendered and simulation for them can be paused to save CPU resources (this is automatic behavior)
-### Trails
-Meep implements a fairly complex trail system, where a trail can be attached to an entity, and it will create a trail behind.
-
-## Audio
-### Sound engine
-Meep has a custom sound engine which is culled and has custom attenuation, this allows scenes to have 1000s of positional audio sources without any extra cost in terms of performance
-
-## Physics
-### High performance spatial index
-Meep features a BVH (bounding volume hierarchy) implementation optimized for speed and memory usage that provides a wide variety of spatial queries, such as:
-* Ray
-* Box
-* Sphere
-* Planar
-* Frustum
-* Point intersection
-* Point distance 
-### Inverse kinematics
-* Meep has 2 very useful IK solvers to fix foot position for characters on uneven terrain or stairs, aligning both the position and orientation of character feet. This works for hands as well if you want and is not limited to bipeds, the system works just as well for, say, spiders.
-* Highly optimized FABRIK inverse kinematics solver for more complex IK use cases
-
-## Other
-### Asset streaming
-Meep in general is a web-first engine, all assets are streamed, meaning that the engine is up and running even before any models/texture are loaded, and you're free to decide when to let the player see your level, wait until everything is loaded or drop them in as soon as you can. There is a pre-loader module in case you want to load some assets in bulk before starting the game.
-### AI tools
-including, but not limited to:
-  * full-fledged Behavior trees
-  * Blackboard (took for recording information useful for AI to read/write relevant world state, very commonly used with Behavior Trees)
-  * monte-carlo tree search (same as Google's AlphaGo, useful for decision-making)
-  * state optimization (useful for decision-making)
-  * grid-based path finding (optimized for 10,000s of queries per second)
-  * resource allocation solver (useful for planning, given certain resources such as bullets/grenades/money/health - plan what actions to take to optimize your chances of winning)
-  * and a number of other useful tools to complement development of game AI and other intelligent behavior use cases.
-### High-performance serialization
-Extremely compact binary serialization system. You can save/load your scenes from files. This serialization system supports format changes, so as you develop your game - old saves will be supported and the system will automatically upgrade them to the most recent version, so the player doesn't have to lose any data.
-### Achievements
-Achievements work with Blackboard components and are very easy to define. There is an abstraction system that helps connect your achievements to various platforms such as Steam or XBox (you'd have to implement that binding yourself though), by default it comes with a browser backend, storing data in IndexedDB. I also have bindings for Steam and NewGrounds that I can share.
-### UI system
-You're free to use it or not, the engine works just fine without it. The system is written for speed, and it offers a few commonly used tools, such as popup windows, notifications and pages. The UI system is optimized for speed, so it generates no garbage, but again - if you want to use, say React - you can ignore this system or integrate it with the system.
-
-
-For more information, please refer to the documentation
 
----
-Copyright © 2025 Company Named Limited, All Rights Reserved
+## License & Copyright
+Copyright © 2025 Company Named Limited, All Rights Reserved.

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.131.19",
+  "version": "2.131.21",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/type/DataType2TypedArrayConstructorMapping.d.ts

@@ -5,7 +5,7 @@
  */
 export function compute_typed_array_constructor_from_data_type(dt: BinaryDataType): constructor | Function;
 /**
- * Mapping from {@DataType} to TypedArray constructors
+ * Mapping from {@link DataType } to TypedArray constructors
  */
 export type DataType2TypedArrayConstructorMapping = Function;
 export namespace DataType2TypedArrayConstructorMapping {

package/src/core/binary/type/DataType2TypedArrayConstructorMapping.js

@@ -2,7 +2,7 @@ import { BinaryDataType } from "./BinaryDataType.js";
 
 
 /**
- * Mapping from {@DataType} to TypedArray constructors
+ * Mapping from {@link DataType} to TypedArray constructors
  * @enum {function}
  */
 export const DataType2TypedArrayConstructorMapping = {

package/src/core/collection/array/computeStridedArrayHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeStridedArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeStridedArrayHash.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wGAPW,MAAM,UACN,MAAM,UACN,MAAM,4BACM,MAAM,6BAEjB,MAAM,CAwBjB"}
+{"version":3,"file":"computeStridedArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeStridedArrayHash.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wGAPW,MAAM,UACN,MAAM,UACN,MAAM,4BACM,MAAM,6BAEjB,MAAM,CAyBjB"}

package/src/core/collection/array/computeStridedArrayHash.js

@@ -27,6 +27,7 @@ export function computeStridedArrayHash(
          * Simple hashing scheme, multiplying existing hash by a prime and adding next value
          * (h<<5) - h ===  h*31
          * @type {number}
+         * @ignore
          */
         hash = ((hash << 5) - hash) + value;
     }

package/src/core/collection/array/computeStridedIntegerArrayHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeStridedIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeStridedIntegerArrayHash.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sDANW,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,UAC3C,MAAM,UACN,MAAM,UACN,MAAM,GACL,MAAM,CAoBjB"}
+{"version":3,"file":"computeStridedIntegerArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/computeStridedIntegerArrayHash.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sDANW,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,UAC3C,MAAM,UACN,MAAM,UACN,MAAM,GACL,MAAM,CAqBjB"}

package/src/core/collection/array/computeStridedIntegerArrayHash.js

@@ -18,6 +18,7 @@ export function computeStridedIntegerArrayHash(
          * Simple hashing scheme, multiplying existing hash by a prime and adding next value
          * (h<<5) - h ===  h*31
          * @type {number}
+         * @ignore
          */
         hash = ((hash << 5) - hash) + value;
     }

package/src/core/color/illuminant/planckian_radiance.js

@@ -1,11 +1,11 @@
 import { assert } from "../../assert.js";
 
 /**
- * Second radiation constant (m·K)
+ * Second radiation constant.
+ * Value is meters Kelvin (m*K).
  *
  * `c2 = (h*c) / (kb)`
- *
- * Value is meters Kelvin (m*K).
+ * @type {number}
  */
 const PLANCK_C2 = 1.438776877e-2;
 
@@ -18,7 +18,7 @@ const PLANCK_C2 = 1.438776877e-2;
 export function planckian_radiance(lambda_m, T) {
     assert.isNumber(lambda_m, 'lambda_m');
     assert.notNaN(lambda_m, 'lambda_m');
-    
+
     assert.isNumber(T, 'T');
     assert.notNaN(T, 'T');
 

package/src/core/geom/2d/aabb/AABB2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AABB2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/AABB2.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"AABB2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/AABB2.js"],"names":[],"mappings":";AAaA;;;GAGG;AACH;IACI;;;;;;OAMG;IACH,iBANW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,EAuChB;IApBG;;;OAGG;IACH,IAFU,MAAM,CAEJ;IACZ;;;OAGG;IACH,IAFU,MAAM,CAEJ;IACZ;;;OAGG;IACH,IAFU,MAAM,CAEJ;IACZ;;;OAGG;IACH,IAFU,MAAM,CAEJ;IA8ChB;;OAEG;IACH,mBAEC;IAtCD;;;OAGG;IACH,gBAEC;IAkCD;;OAEG;IACH,mBAEC;IArCD;;;OAGG;IACH,gBAEC;IAiCD;;OAEG;IACH,mBAEC;IApCD;;;OAGG;IACH,gBAEC;IAgCD;;OAEG;IACH,mBAEC;IAnCD;;;OAGG;IACH,gBAEC;IA+BD;;;OAGG;IACH,gBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,WAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,aAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QA8BlB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAShB;IAED;;;;;OAKG;IACH,sBAJW,KAAK,UACL,KAAK,GACH,OAAO,CAcnB;IAED;;;;OAIG;IACH,qBAHW,KAAK,GACH,OAAO,CAcnB;IAED;;;;;;;OAOG;IACH,0EAMC;IAED;;;;OAIG;IACH,qBAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;;;;OAMG;IACH,0BALW,OAAO,MACP,OAAO,UACP,OAAO,GACL,OAAO,CA0BnB;IAED;;;;OAIG;IACH,kCAHW,OAAO,UACP,OAAO,QAmBjB;IAED;;;;OAIG;IACH,wBAHW,KAAK,GACH,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,sBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CA4BlB;IAED;;;OAGG;IACH,eAFa,MAAM,CASlB;IAED;;;OAGG;IACH,sBAFY,MAAM,CAYjB;IAED;;;;;OAKG;IACH,iBAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAFW,KAAK,QAIf;IAED;;;OAGG;IACH,mBAFW,OAAO,WAOjB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,aAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,qBAEC;IAED;;;;;;;;;OASG;IACH,qDAJa,IAAI,CAqBhB;IAED;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,aAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAOhB;IAED;;;OAGG;IACH,SAFa,KAAK,CAIjB;IAED;;;;OAIG;IACH,YAHW,KAAK,GACH,KAAK,CAIjB;IAED;;;;OAIG;IACH,cAHW,KAAK,GACH,OAAO,CAOnB;IAED;;;OAGG;IACH,QAFY,MAAM,CA4BjB;IAED;;;;;;OAMG;IACH,UALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAQhB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsBhB;IAED;;OAEG;IACH,oCAEC;IAED,mBAEC;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;;OAIG;IACH,iBAJW,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,GACJ,MAAM,EAAE,GAAC,YAAY,CAUjC;IAkCL;;;OAGG;IACH,kBAFU,OAAO,CAEM;IA9qBnB,sDAQC;CAioBJ;;;qBA+CS,KAAK;qBAUL,KAAK;;oBA5vBK,kBAAkB;AAssBtC;;;;;;;GAOG;AACH,gDANW,KAAK,MACL,KAAK,MACL,OAAO,MACP,OAAO,GACL,OAAO,CAsBnB"}

package/src/core/geom/2d/aabb/AABB2.js

@@ -555,7 +555,7 @@ class AABB2 {
     }
 
     /**
-     * Relative displacement of the AABB by given vector described by {@param deltaX} and {@param deltaY}
+     * Relative displacement of the AABB by given vector described by {@link deltaX} and {@link deltaY}
      * @param {number} deltaX displacement in X
      * @param {number} deltaY displacement in Y
      * @returns {this}
@@ -749,6 +749,9 @@ function computeLineBetweenTwoBoxes(b0, b1, p0, p1) {
  */
 AABB2.prototype.isAABB2 = true;
 
+/**
+ * Alias
+ */
 AABB2.computeLineBetweenTwoBoxes = computeLineBetweenTwoBoxes;
 
 /**

package/src/core/geom/3d/mat4/eulerAnglesFromMatrix.d.ts

@@ -1,23 +1,28 @@
 /**
  *
- * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2)
+ * returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (`a0`,`a1`,`a2`)
  *
- * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}.
+ * Each of the three parameters `a0`, `a1`, `a2` represents the respective rotation axis as an integer in {0,1,2}.
  * For instance, in:
- * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode
+ * ```
+ * Vector3f ea = mat.eulerAngles(2, 0, 2);
+ * ```
  * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
  * we have the following equality:
- * \code
+ * ```
  * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
  *      * AngleAxisf(ea[1], Vector3f::UnitX())
- *      * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
+ *      * AngleAxisf(ea[2], Vector3f::UnitZ());
+ * ```
  * This corresponds to the right-multiply conventions (with right hand side frames).
  *
  * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
 
  * NOTE: ported from Eigen C++ library
+ *
  * @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/EulerAngles.h
  * @see https://stackoverflow.com/questions/11514063/extract-yaw-pitch-and-roll-from-a-rotationmatrix
+ *
  * @param {number[]} output
  * @param {number[]|Float32Array|mat4} m4 source matrix to extract rotation from
  * @param {number} a0 axis index (0 = X, 1 = Y, 2 = Z)

package/src/core/geom/3d/mat4/eulerAnglesFromMatrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eulerAnglesFromMatrix.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/eulerAnglesFromMatrix.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8CANW,MAAM,EAAE,MACR,MAAM,EAAE,GAAC,YAAY,OAAK,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,QA2EhB"}
+{"version":3,"file":"eulerAnglesFromMatrix.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/eulerAnglesFromMatrix.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8CANW,MAAM,EAAE,MACR,MAAM,EAAE,GAAC,YAAY,OAAK,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,QA2EhB"}

package/src/core/geom/3d/mat4/eulerAnglesFromMatrix.js

@@ -7,6 +7,7 @@ import { v2_length } from "../../vec2/v2_length.js";
  * @param {number} row_index
  * @param {number} column_index
  * @return {number}
+ * @ignore
  */
 function coeff(mat4, row_index, column_index) {
     return mat4[row_index + column_index * 4];
@@ -18,24 +19,29 @@ const atan2 = Math.atan2;
 
 /**
  *
- * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2)
+ * returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (`a0`,`a1`,`a2`)
  *
- * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}.
+ * Each of the three parameters `a0`, `a1`, `a2` represents the respective rotation axis as an integer in {0,1,2}.
  * For instance, in:
- * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode
+ * ```
+ * Vector3f ea = mat.eulerAngles(2, 0, 2);
+ * ```
  * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
  * we have the following equality:
- * \code
+ * ```
  * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
  *      * AngleAxisf(ea[1], Vector3f::UnitX())
- *      * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
+ *      * AngleAxisf(ea[2], Vector3f::UnitZ());
+ * ```
  * This corresponds to the right-multiply conventions (with right hand side frames).
  *
  * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
 
  * NOTE: ported from Eigen C++ library
+ *
  * @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/EulerAngles.h
  * @see https://stackoverflow.com/questions/11514063/extract-yaw-pitch-and-roll-from-a-rotationmatrix
+ *
  * @param {number[]} output
  * @param {number[]|Float32Array|mat4} m4 source matrix to extract rotation from
  * @param {number} a0 axis index (0 = X, 1 = Y, 2 = Z)

package/src/core/math/inverseLerp.d.ts

@@ -8,7 +8,7 @@
  * @param {number} a
  * @param {number} b
  * @param {number} value
- * @returns {number} fraction of where the {@link value{} lies between {@link a} and {@link b}
+ * @returns {number} fraction of where the {@link value} lies between {@link a} and {@link b}
  */
 export function inverseLerp(a: number, b: number, value: number): number;
 //# sourceMappingURL=inverseLerp.d.ts.map

package/src/core/math/inverseLerp.js

@@ -8,7 +8,7 @@
  * @param {number} a
  * @param {number} b
  * @param {number} value
- * @returns {number} fraction of where the {@link value{} lies between {@link a} and {@link b}
+ * @returns {number} fraction of where the {@link value} lies between {@link a} and {@link b}
  */
 export function inverseLerp(a, b, value) {
     const range = b - a;
@@ -18,7 +18,7 @@ export function inverseLerp(a, b, value) {
 
         // avoid division by zero error
 
-        // this is arbitrary output, as actual answer is undefined
+        // this is arbitrary output, as the actual answer is undefined
 
         return 0;
     }

package/src/core/math/sign.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sign.d.ts","sourceRoot":"","sources":["../../../../src/core/math/sign.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAHW,MAAM,GACJ,MAAM,CAIlB"}
+{"version":3,"file":"sign.d.ts","sourceRoot":"","sources":["../../../../src/core/math/sign.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAHW,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/math/sign.js

@@ -1,7 +1,10 @@
 /**
+ * Positive number produce 1, negative -1 and 0 produces 0.
+ *
+ * Standard implementation in graphics languages such as HLSL and GLSL
  *
  * @param {number} v
- * @returns {number} +1 if v>0, 0 if v == 0, -1 if v<0
+ * @returns {number} +1 if `v > 0`, 0 if `v == 0`, -1 if `v < 0`
  */
 export function sign(v) {
     return v > 0 ? 1 : (v < 0 ? -1 : 0);

package/src/engine/asset/loaders/image/codec/NativeImageDecoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeImageDecoder.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/codec/NativeImageDecoder.js"],"names":[],"mappings":"AAyDA;;;GAGG;AACH;WAF0B,MAAM;YAAS,MAAM;UAAQ,UAAU;cAAY,MAAM;cAAW,MAAM;;;IAGhG;;;;OAIG;IACH,iBAHW,UAAU,GACT;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAgBhG;IAED;;;;;;OAiBC;CACJ;sBArGqB,YAAY"}
+{"version":3,"file":"NativeImageDecoder.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/codec/NativeImageDecoder.js"],"names":[],"mappings":"AA4DA;;;GAGG;AACH;WAF0B,MAAM;YAAS,MAAM;UAAQ,UAAU;cAAY,MAAM;cAAW,MAAM;;;IAGhG;;;;OAIG;IACH,iBAHW,UAAU,GACT;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAgBhG;IAED;;;;;;OAiBC;CACJ;sBAxGqB,YAAY"}

package/src/engine/asset/loaders/image/codec/NativeImageDecoder.js

@@ -4,6 +4,7 @@ import { Codec } from "./Codec.js";
  *
  * @param {Image|ImageBitmap|HTMLImageElement} img
  * @returns {Uint8Array}
+ * @ignore
  */
 function decode(img) {
     const width = img.width;
@@ -27,6 +28,7 @@ function decode(img) {
 /**
  *
  * @param {HTMLImageElement} image
+ * @ignore
  */
 function make_decoded_data(image) {
 
@@ -49,6 +51,7 @@ function make_decoded_data(image) {
  * Don't forget to call `URL.revokeObjectURL(url)` when done
  * @param {Uint8Array} data
  * @return {string}
+ * @ignore
  */
 function data_to_url(data){
     const blob = new Blob([data]);

package/src/engine/asset/loaders/image/png/PNGReader.d.ts

@@ -163,9 +163,12 @@ export class PNGReader {
      * @param {number} output_offset
      * @param {number} output_offset_previous where does result of previous scanline begin in the output? Needed for various filters such as `Up`
      * @param {number} length
+     *
+     * @see https://www.w3.org/TR/PNG-Filters.html
      */
     unFilter(filter_type: number, data: Uint8Array, scanline_address: number, output: Uint8Array, bytes_per_pixel: number, output_offset: number, output_offset_previous: number, length: number): void;
     /**
+     * With the None filter, the scanline is transmitted unmodified; it is only necessary to insert a filter type byte before the data.
      *
      * @param {Uint8Array} data
      * @param {number} scanline_address
@@ -174,12 +177,14 @@ export class PNGReader {
      * @param {number} output_offset
      * @param {number} output_offset_previous
      * @param {number} length
+     *
+     * @see https://www.w3.org/TR/PNG-Filters.html
      */
     unFilterNone(data: Uint8Array, scanline_address: number, output: Uint8Array, bytes_per_pixel: number, output_offset: number, output_offset_previous: number, length: number): void;
     /**
-     * The Sub() filter transmits the difference between each byte and the value
+     * The `Sub` filter transmits the difference between each byte and the value
      * of the corresponding byte of the prior pixel.
-     * Sub(x) = Raw(x) + Raw(x - bpp)
+     * `Sub(x) = Raw(x) + Raw(x - bpp)`
      *
      * @param {Uint8Array} scanline raw data
      * @param {number} scanline_offset
@@ -188,13 +193,14 @@ export class PNGReader {
      * @param {number} offset
      * @param {number} output_offset_previous
      * @param {number} length
+     * @see https://www.w3.org/TR/PNG-Filters.html
      */
     unFilterSub(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
     /**
-     * The Up() filter is just like the Sub() filter except that the pixel
+     * The `Up` filter is just like the Sub() filter except that the pixel
      * immediately above the current pixel, rather than just to its left, is used
      * as the predictor.
-     * Up(x) = Raw(x) + Prior(x)
+     * `Up(x) = Raw(x) + Prior(x)`
      *
      * @param {Uint8Array} scanline raw data
      * @param {number} scanline_offset
@@ -203,12 +209,14 @@ export class PNGReader {
      * @param {number} offset
      * @param {number} output_offset_previous
      * @param {number} length
+     * @see https://www.w3.org/TR/PNG-Filters.html
      */
     unFilterUp(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
     /**
-     * The Average() filter uses the average of the two neighboring pixels (left
+     * The `Average` filter uses the average of the two neighboring pixels (left
      * and above) to predict the value of a pixel.
-     * Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)
+     *
+     * `Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)`
      *
      * @param {Uint8Array} scanline raw data
      * @param {number} scanline_offset
@@ -217,29 +225,14 @@ export class PNGReader {
      * @param {number} offset
      * @param {number} output_offset_previous
      * @param {number} length
+     *
+     * @see https://www.w3.org/TR/PNG-Filters.html
      */
     unFilterAverage(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
     /**
-     * The Paeth() filter computes a simple linear function of the three
-     * neighboring pixels (left, above, upper left), then chooses as predictor
-     * the neighboring pixel closest to the computed value.
-     * This technique is due to Alan W. Paeth.
+     * The `Paeth` filter computes a simple linear function of the three neighboring pixels (left, above, upper left), then chooses as predictor the neighboring pixel closest to the computed value.
      *
-     * Paeth(x) = Raw(x) +
-     *            PaethPredictor(Raw(x-bpp), Prior(x), Prior(x-bpp))
-     *  function PaethPredictor (a, b, c)
-     *  begin
-     *       ; a = left, b = above, c = upper left
-     *       p := a + b - c        ; initial estimate
-     *       pa := abs(p - a)      ; distances to a, b, c
-     *       pb := abs(p - b)
-     *       pc := abs(p - c)
-     *       ; return nearest of a,b,c,
-     *       ; breaking ties in order a,b,c.
-     *       if pa <= pb AND pa <= pc then return a
-     *       else if pb <= pc then return b
-     *       else return c
-     *  end
+     * This technique is due to Alan W. Paeth.
      *
      * @param {Uint8Array} scanline raw data
      * @param {number} scanline_offset
@@ -248,6 +241,8 @@ export class PNGReader {
      * @param {number} offset
      * @param {number} output_offset_previous
      * @param {number} length
+     *
+     * @see https://www.w3.org/TR/PNG-Filters.html
      */
     unFilterPaeth(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
     /**

package/src/engine/asset/loaders/image/png/PNGReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNGReader.js"],"names":[],"mappings":"AAyDA;;;;GAIG;AACH,iCAHW,WAAW,QAkDrB;;IApDD;;;;OAIG;IACH,mBAHW,WAAW,EAkDrB;IA9CG;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,UAAU,CAEc;IAElC;;;OAGG;IACH,KAFU,GAAG,CAEO;IAEpB;;;OAGG;IACH,YAFU,UAAU,EAAE,CAEF;IAEpB;;;OAGG;IACH,QAFU,YAAY,CAEU;IAOhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,QAFU,UAAU,CAEW;IAGnC;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAarB;IAED;;OAEG;IACH,qBAkBC;IAED;;;;;;;;;OASG;IACH,eAFa,MAAM,CA4ElB;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;;OAIG;IACH,kBAFW,UAAU;;;;;MAuCpB;IAGD;;;;OAIG;IACH,kBAFW,UAAU;;;MAiCpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAwBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;;OAIG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;OAEG;IACH,qBAyBC;IAID;;OAEG;IACH,oBAFW,UAAU,cA+CpB;IAGD;;;OAGG;IACH,qBAFW,UAAU,4BA8GpB;IAID;;;;;;;;;;OAUG;IACH,sBATW,MAAM,QACN,UAAU,oBACV,MAAM,UACN,UAAU,mBACV,MAAM,iBACN,MAAM,0BACN,MAAM,UACN,MAAM,QA6EhB;IAED;;;;;;;;;OASG;IACH,mBARW,UAAU,oBACV,MAAM,UACN,UAAU,mBACV,MAAM,iBACN,MAAM,0BACN,MAAM,UACN,MAAM,QA+ChB;IAED;;;;;;;;;;;;OAYG;IACH,sBARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAwBhB;IAED;;;;;;;;;;;;;OAaG;IACH,qBARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAkChB;IAED;;;;;;;;;;;;OAYG;IACH,0BARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA4ChB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,wBARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA4DhB;IAED;;;OAGG;IACH,SAFa,GAAG,CAqBf;;oBA3gCmB,UAAU;6BAND,4CAA4C"}
+{"version":3,"file":"PNGReader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/PNGReader.js"],"names":[],"mappings":"AAyDA;;;;GAIG;AACH,iCAHW,WAAW,QAkDrB;;IApDD;;;;OAIG;IACH,mBAHW,WAAW,EAkDrB;IA9CG;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,UAAU,CAEc;IAElC;;;OAGG;IACH,KAFU,GAAG,CAEO;IAEpB;;;OAGG;IACH,YAFU,UAAU,EAAE,CAEF;IAEpB;;;OAGG;IACH,QAFU,YAAY,CAEU;IAOhC;;;OAGG;IACH,aAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,QAFU,UAAU,CAEW;IAGnC;;;;OAIG;IACH,kBAHW,MAAM,GACL,UAAU,CAarB;IAED;;OAEG;IACH,qBAkBC;IAED;;;;;;;;;OASG;IACH,eAFa,MAAM,CA4ElB;IAGD;;;OAGG;IACH,kBAFW,UAAU,QAOpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QAapB;IAED;;;;OAIG;IACH,kBAFW,UAAU;;;;;MAuCpB;IAGD;;;;OAIG;IACH,kBAFW,UAAU;;;MAiCpB;IAED;;;OAGG;IACH,kBAFW,UAAU,QASpB;IACD;;;;OAIG;IACH,kBAFW,UAAU,QAwBpB;IAED;;;;;;;;;;;OAWG;IACH,6BAWC;IAED;;;;OAIG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,6BAGC;IAED;;;OAGG;IACH,kBAFW,UAAU,QAIpB;IAED;;OAEG;IACH,mBACC;IAED;;OAEG;IACH,qBAyBC;IAID;;OAEG;IACH,oBAFW,UAAU,cA+CpB;IAGD;;;OAGG;IACH,qBAFW,UAAU,4BA8GpB;IAID;;;;;;;;;;;;OAYG;IACH,sBAXW,MAAM,QACN,UAAU,oBACV,MAAM,UACN,UAAU,mBACV,MAAM,iBACN,MAAM,0BACN,MAAM,UACN,MAAM,QA+EhB;IAED;;;;;;;;;;;;OAYG;IACH,mBAVW,UAAU,oBACV,MAAM,UACN,UAAU,mBACV,MAAM,iBACN,MAAM,0BACN,MAAM,UACN,MAAM,QAiDhB;IAED;;;;;;;;;;;;;OAaG;IACH,sBATW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAyBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,qBATW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QAmChB;IAED;;;;;;;;;;;;;;;OAeG;IACH,0BAVW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA8ChB;IAED;;;;;;;;;;;;;;OAcG;IACH,wBAVW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA8DhB;IAED;;;OAGG;IACH,SAFa,GAAG,CAqBf;;oBAtgCmB,UAAU;6BAND,4CAA4C"}

package/src/engine/asset/loaders/image/png/PNGReader.js

@@ -654,6 +654,8 @@ PNGReader.prototype.interlaceAdam7 = function (data) {
  * @param {number} output_offset
  * @param {number} output_offset_previous where does result of previous scanline begin in the output? Needed for various filters such as `Up`
  * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
  */
 PNGReader.prototype.unFilter = function (
     filter_type,
@@ -733,6 +735,7 @@ PNGReader.prototype.unFilter = function (
 }
 
 /**
+ * With the None filter, the scanline is transmitted unmodified; it is only necessary to insert a filter type byte before the data.
  *
  * @param {Uint8Array} data
  * @param {number} scanline_address
@@ -741,6 +744,8 @@ PNGReader.prototype.unFilter = function (
  * @param {number} output_offset
  * @param {number} output_offset_previous
  * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
  */
 PNGReader.prototype.unFilterNone = function (
     data,
@@ -790,9 +795,9 @@ PNGReader.prototype.unFilterNone = function (
 };
 
 /**
- * The Sub() filter transmits the difference between each byte and the value
+ * The `Sub` filter transmits the difference between each byte and the value
  * of the corresponding byte of the prior pixel.
- * Sub(x) = Raw(x) + Raw(x - bpp)
+ * `Sub(x) = Raw(x) + Raw(x - bpp)`
  *
  * @param {Uint8Array} scanline raw data
  * @param {number} scanline_offset
@@ -801,6 +806,7 @@ PNGReader.prototype.unFilterNone = function (
  * @param {number} offset
  * @param {number} output_offset_previous
  * @param {number} length
+ * @see https://www.w3.org/TR/PNG-Filters.html
  */
 PNGReader.prototype.unFilterSub = function (
     scanline,
@@ -827,10 +833,10 @@ PNGReader.prototype.unFilterSub = function (
 };
 
 /**
- * The Up() filter is just like the Sub() filter except that the pixel
+ * The `Up` filter is just like the Sub() filter except that the pixel
  * immediately above the current pixel, rather than just to its left, is used
  * as the predictor.
- * Up(x) = Raw(x) + Prior(x)
+ * `Up(x) = Raw(x) + Prior(x)`
  *
  * @param {Uint8Array} scanline raw data
  * @param {number} scanline_offset
@@ -839,6 +845,7 @@ PNGReader.prototype.unFilterSub = function (
  * @param {number} offset
  * @param {number} output_offset_previous
  * @param {number} length
+ * @see https://www.w3.org/TR/PNG-Filters.html
  */
 PNGReader.prototype.unFilterUp = function (
     scanline,
@@ -875,9 +882,10 @@ PNGReader.prototype.unFilterUp = function (
 };
 
 /**
- * The Average() filter uses the average of the two neighboring pixels (left
+ * The `Average` filter uses the average of the two neighboring pixels (left
  * and above) to predict the value of a pixel.
- * Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)
+ *
+ * `Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)`
  *
  * @param {Uint8Array} scanline raw data
  * @param {number} scanline_offset
@@ -886,6 +894,8 @@ PNGReader.prototype.unFilterUp = function (
  * @param {number} offset
  * @param {number} output_offset_previous
  * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
  */
 PNGReader.prototype.unFilterAverage = function (
     scanline,
@@ -932,26 +942,9 @@ PNGReader.prototype.unFilterAverage = function (
 };
 
 /**
- * The Paeth() filter computes a simple linear function of the three
- * neighboring pixels (left, above, upper left), then chooses as predictor
- * the neighboring pixel closest to the computed value.
- * This technique is due to Alan W. Paeth.
+ * The `Paeth` filter computes a simple linear function of the three neighboring pixels (left, above, upper left), then chooses as predictor the neighboring pixel closest to the computed value.
  *
- * Paeth(x) = Raw(x) +
- *            PaethPredictor(Raw(x-bpp), Prior(x), Prior(x-bpp))
- *  function PaethPredictor (a, b, c)
- *  begin
- *       ; a = left, b = above, c = upper left
- *       p := a + b - c        ; initial estimate
- *       pa := abs(p - a)      ; distances to a, b, c
- *       pb := abs(p - b)
- *       pc := abs(p - c)
- *       ; return nearest of a,b,c,
- *       ; breaking ties in order a,b,c.
- *       if pa <= pb AND pa <= pc then return a
- *       else if pb <= pc then return b
- *       else return c
- *  end
+ * This technique is due to Alan W. Paeth.
  *
  * @param {Uint8Array} scanline raw data
  * @param {number} scanline_offset
@@ -960,6 +953,8 @@ PNGReader.prototype.unFilterAverage = function (
  * @param {number} offset
  * @param {number} output_offset_previous
  * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
  */
 PNGReader.prototype.unFilterPaeth = function (
     scanline,

package/src/engine/ecs/gui/GUIElementSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GUIElementSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElementSystem.js"],"names":[],"mappings":"AAgCA,gFAAiF;;AAEjF;IAyBI;;;;;OAKG;IACH,2BAJW,IAAI,kBAqCd;IA9DD,gBAaG;IAEH,oCAA4B;IAE5B;;;OAGG;IACH,YAAY;IA2BR,iCAAkC;IAGlC;;OAEG;IACH,8BAA0C;IAE1C;;;OAGG;IACH,eAAoB;IAIxB,gCAGC;IAED,iCAEC;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QA6DhB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QAoBhB;IAED;;;;OAIG;IACH,gBAHW,UAAU,qBAiDpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,qBAiBpB;CACJ;uBA/QsB,cAAc;sBAFf,qCAAqC;uBAGhB,iBAAiB;iBAF3C,uBAAuB"}
+{"version":3,"file":"GUIElementSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElementSystem.js"],"names":[],"mappings":"AAiCA,gFAAiF;;AAEjF;IAyBI;;;;;OAKG;IACH,2BAJW,IAAI,kBAqCd;IA9DD,gBAaG;IAEH,oCAA4B;IAE5B;;;OAGG;IACH,YAAY;IA2BR,iCAAkC;IAGlC;;OAEG;IACH,8BAA0C;IAE1C;;;OAGG;IACH,eAAoB;IAIxB,gCAGC;IAED,iCAEC;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QA6DhB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QAoBhB;IAED;;;;OAIG;IACH,gBAHW,UAAU,qBAiDpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,qBAiBpB;CACJ;uBAhRsB,cAAc;sBAFf,qCAAqC;uBAGhB,iBAAiB;iBAF3C,uBAAuB"}

package/src/engine/ecs/gui/GUIElementSystem.js

@@ -7,6 +7,7 @@ import { GUIElementEvent } from "./GUIElementEvent.js";
 /**
  * @this {{el:GUIElement, system:GUIElementSystem, entity: number}}
  * @param {boolean} v
+ * @ignore
  */
 function handleComponentVisibilityChange(v) {
     /**

package/src/engine/ecs/gui/position/ViewportPositionSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewportPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPositionSystem.js"],"names":[],"mappings":";AAsBA;IACI,+BAoBC;IAjBG,8DAAkD;IAElD,kEAEC;IAED,kBAAgC;IAEhC,yCAME;IAEF,SAAc;IAGlB,2CAEC;IAED,4CAEC;IAED;;;OAGG;IACH,sBAHW,UAAU,MACV,gBAAgB,QAkE1B;IAED;;;;;OAKG;IACH,SAJW,gBAAgB,MAChB,UAAU,qBA8BpB;IAED;;;;;OAKG;IACH,WAJW,gBAAgB,MAChB,UAAU,qBAmBpB;IA4EL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CA7ExD;uBAjLsB,iBAAiB;uBACjB,kBAAkB;6BAEZ,uBAAuB;4CAJR,uDAAuD;8BAJrE,iDAAiD"}
+{"version":3,"file":"ViewportPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPositionSystem.js"],"names":[],"mappings":";AAuBA;IACI,+BAoBC;IAjBG,8DAAkD;IAElD,kEAEC;IAED,kBAAgC;IAEhC,yCAME;IAEF,SAAc;IAGlB,2CAEC;IAED,4CAEC;IAED;;;OAGG;IACH,sBAHW,UAAU,MACV,gBAAgB,QAkE1B;IAED;;;;;OAKG;IACH,SAJW,gBAAgB,MAChB,UAAU,qBA8BpB;IAED;;;;;OAKG;IACH,WAJW,gBAAgB,MAChB,UAAU,qBAmBpB;IA4EL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CA7ExD;uBAlLsB,iBAAiB;uBACjB,kBAAkB;6BAEZ,uBAAuB;4CAJR,uDAAuD;8BAJrE,iDAAiD"}

package/src/engine/ecs/gui/position/ViewportPositionSystem.js

@@ -13,6 +13,7 @@ const CSS_CLASS = 'ecs-viewport-position-component';
 
 /**
  * @this {{system:ViewportPositionSystem, vp: ViewportPosition, el: GUIElement}}
+ * @ignore
  */
 function updatePosition() {
     this.system.positionComponent(this.el, this.vp);