wuepgg3-track 1.0.5 → 1.0.6

package/dist/{SharedSystems-DFBznyti.mjs → SharedSystems-DAGvNH0M.mjs}

@@ -1,6 +1,6 @@
-import { s as He, G as te, u as re, v as Le, k as se, M as v, x as ae, E as u, e as D, y as g, z as ze, F as O, H as y, R as F, I as ne, J as We, t as m, S as f, h as B, w as ie, K as q, L as Ve, b as K, B as C, i as U, N as M, j as T, O as w, Q as Ne, a as je, V as oe, W as le, X as ue, Y as de, C as P, Z as ce, _ as $e, P as qe, c as Ke, T as Y, D as he, $ as J, a0 as Ye, a1 as Je, a2 as Xe } from "./index-B6bI9_jA.mjs";
-import { S as fe, B as pe, c as Qe } from "./colorToUniform-BcHZBaJ_.mjs";
-const me = class A extends He {
+import { q as Le, G as te, t as re, u as He, k as se, M as v, v as ae, E as u, e as E, x as S, y as ze, z as O, F as b, R as F, H as ne, I as We, s as m, S as f, h as B, w as ie, J as q, K as Ve, b as K, B as k, i as U, L as M, j as T, N as w, O as Ne, a as je, Q as oe, V as le, W as ue, X as de, C as P, Y as ce, Z as $e, P as qe, c as Ke, T as Y, D as he, _ as J, $ as Ye, a0 as Je, a1 as Xe } from "./index-mf0sUiUk.mjs";
+import { S as fe, B as pe, c as Qe } from "./colorToUniform-zJcCVLeu.mjs";
+const me = class A extends Le {
   /**
    * @param options - The optional parameters of this filter.
    */
@@ -224,7 +224,7 @@ fn mainFragment(
 `;
 class rt extends Ze {
   constructor(e) {
-    const { sprite: t, ...r } = e, s = new Le(t.texture), n = new se({
+    const { sprite: t, ...r } = e, s = new He(t.texture), n = new se({
       uFilterMatrix: { value: new v(), type: "mat3x3<f32>" },
       uMaskClamp: { value: s.uClampFrame, type: "vec4<f32>" },
       uAlpha: { value: 1, type: "f32" },
@@ -266,7 +266,7 @@ class rt extends Ze {
     ).prepend(this._textureMatrix.mapCoord), this.resources.uMaskTexture = this.sprite.texture.source, e.applyFilter(this, t, r, s);
   }
 }
-const H = class ve {
+const L = class ve {
   constructor(e, t) {
     var r, s;
     this.state = fe.for2d(), this._batchersByInstructionSet = /* @__PURE__ */ Object.create(null), this._activeBatches = /* @__PURE__ */ Object.create(null), this.renderer = e, this._adaptor = t, (s = (r = this._adaptor).init) == null || s.call(r, this);
@@ -276,7 +276,9 @@ const H = class ve {
   }
   buildStart(e) {
     let t = this._batchersByInstructionSet[e.uid];
-    t || (t = this._batchersByInstructionSet[e.uid] = /* @__PURE__ */ Object.create(null), t.default || (t.default = new ae())), this._activeBatches = t, this._activeBatch = this._activeBatches.default;
+    t || (t = this._batchersByInstructionSet[e.uid] = /* @__PURE__ */ Object.create(null), t.default || (t.default = new ae({
+      maxTextures: this.renderer.limits.maxBatchableTextures
+    }))), this._activeBatches = t, this._activeBatch = this._activeBatches.default;
     for (const r in this._activeBatches)
       this._activeBatches[r].begin();
   }
@@ -320,7 +322,7 @@ const H = class ve {
     this._activeBatches = null;
   }
 };
-H.extension = {
+L.extension = {
   type: [
     u.WebGLPipes,
     u.WebGPUPipes,
@@ -328,10 +330,10 @@ H.extension = {
   ],
   name: "batch"
 };
-H._availableBatchers = /* @__PURE__ */ Object.create(null);
-let ge = H;
-D.handleByMap(u.Batcher, ge._availableBatchers);
-D.add(ae);
+L._availableBatchers = /* @__PURE__ */ Object.create(null);
+let xe = L;
+E.handleByMap(u.Batcher, xe._availableBatchers);
+E.add(ae);
 const Bt = {
   name: "texture-bit",
   vertex: {
@@ -360,7 +362,7 @@ const Bt = {
             @group(2) @binding(0) var uTexture: texture_2d<f32>;
             @group(2) @binding(1) var uSampler: sampler;
 
-         
+
         `
     ),
     main: (
@@ -392,7 +394,7 @@ const Bt = {
       `
         uniform sampler2D uTexture;
 
-         
+
         `
     ),
     main: (
@@ -425,7 +427,7 @@ class at extends ne {
     this.filters[0].inverse = e;
   }
 }
-class xe {
+class ge {
   constructor(e) {
     this._activeMaskStage = [], this._renderer = e;
   }
@@ -467,12 +469,12 @@ class xe {
   execute(e) {
     const t = this._renderer, r = e.mask.renderMaskToTexture;
     if (e.action === "pushMaskBegin") {
-      const s = g.get(at);
+      const s = S.get(at);
       if (s.inverse = e.inverse, r) {
         e.mask.mask.measurable = !0;
         const n = ze(e.mask.mask, !0, st);
         e.mask.mask.measurable = !1, n.ceil();
-        const i = t.renderTarget.renderTarget.colorTexture.source, o = y.getOptimalTexture(
+        const i = t.renderTarget.renderTarget.colorTexture.source, o = b.getOptimalTexture(
           n.width,
           n.height,
           i._resolution,
@@ -505,14 +507,14 @@ class xe {
     } else if (e.action === "popMaskEnd") {
       t.filter.pop();
       const s = this._activeMaskStage.pop();
-      r && y.returnTexture(s.filterTexture), g.return(s.filterEffect);
+      r && b.returnTexture(s.filterTexture), S.return(s.filterEffect);
     }
   }
   destroy() {
     this._renderer = null, this._activeMaskStage = null;
   }
 }
-xe.extension = {
+ge.extension = {
   type: [
     u.WebGLPipes,
     u.WebGPUPipes,
@@ -657,13 +659,13 @@ function nt(a) {
     i.stride ?? (i.stride = r[i.buffer.uid]), i.start ?? (i.start = s[i.buffer.uid]), s[i.buffer.uid] += q(i.format).stride;
   }
 }
-const _ = [];
-_[f.NONE] = void 0;
-_[f.DISABLED] = {
+const g = [];
+g[f.NONE] = void 0;
+g[f.DISABLED] = {
   stencilWriteMask: 0,
   stencilReadMask: 0
 };
-_[f.RENDERING_MASK_ADD] = {
+g[f.RENDERING_MASK_ADD] = {
   stencilFront: {
     compare: "equal",
     passOp: "increment-clamp"
@@ -673,7 +675,7 @@ _[f.RENDERING_MASK_ADD] = {
     passOp: "increment-clamp"
   }
 };
-_[f.RENDERING_MASK_REMOVE] = {
+g[f.RENDERING_MASK_REMOVE] = {
   stencilFront: {
     compare: "equal",
     passOp: "decrement-clamp"
@@ -683,7 +685,7 @@ _[f.RENDERING_MASK_REMOVE] = {
     passOp: "decrement-clamp"
   }
 };
-_[f.MASK_ACTIVE] = {
+g[f.MASK_ACTIVE] = {
   stencilWriteMask: 0,
   stencilFront: {
     compare: "equal",
@@ -694,15 +696,15 @@ _[f.MASK_ACTIVE] = {
     passOp: "keep"
   }
 };
-_[f.INVERSE_MASK_ACTIVE] = {
+g[f.INVERSE_MASK_ACTIVE] = {
   stencilWriteMask: 0,
   stencilFront: {
     compare: "not-equal",
-    passOp: "replace"
+    passOp: "keep"
   },
   stencilBack: {
     compare: "not-equal",
-    passOp: "replace"
+    passOp: "keep"
   }
 };
 class It {
@@ -722,7 +724,7 @@ class It {
     const t = this.getUniformGroupData(e);
     e.buffer || (e.buffer = new K({
       data: new Float32Array(t.layout.size / 4),
-      usage: C.UNIFORM | C.COPY_DST
+      usage: k.UNIFORM | k.COPY_DST
     }));
   }
   getUniformGroupData(e) {
@@ -747,7 +749,7 @@ class It {
     const s = this.getUniformGroupData(e);
     e.buffer || (e.buffer = new K({
       data: new Float32Array(s.layout.size / 4),
-      usage: C.UNIFORM | C.COPY_DST
+      usage: k.UNIFORM | k.COPY_DST
     }));
     let n = null;
     return t || (t = e.buffer.data, n = e.buffer.dataInt32), r || (r = 0), s.syncFunction(e.uniforms, t, n, r), !0;
@@ -763,7 +765,7 @@ class It {
     this._syncFunctionHash = null;
   }
 }
-const S = [
+const C = [
   // uploading pixi matrix object to mat3
   {
     type: "mat3x3<f32>",
@@ -884,12 +886,12 @@ function Gt(a, e, t, r) {
   for (let o = 0; o < a.length; o++) {
     const l = a[o], d = l.data.name;
     let c = !1, h = 0;
-    for (let p = 0; p < S.length; p++)
-      if (S[p].test(l.data)) {
+    for (let p = 0; p < C.length; p++)
+      if (C[p].test(l.data)) {
         h = l.offset / 4, s.push(
           `name = "${d}";`,
           `offset += ${h - n};`,
-          S[p][e] || S[p].ubo
+          C[p][e] || C[p].ubo
         ), c = !0;
         break;
       }
@@ -980,7 +982,7 @@ const it = {
   "mat4x3<f32>": x(4, 3),
   "mat2x4<f32>": x(2, 4),
   "mat3x4<f32>": x(3, 4)
-}, Et = {
+}, Dt = {
   ...it,
   "mat2x2<f32>": `
         data[offset] = v[0];
@@ -993,26 +995,26 @@ function ot(a, e, t, r, s, n) {
   const i = n ? 1 : -1;
   return a.identity(), a.a = 1 / r * 2, a.d = i * (1 / s * 2), a.tx = -1 - e * a.a, a.ty = -i - t * a.d, a;
 }
-const b = /* @__PURE__ */ new Map();
-function ye(a, e) {
-  if (!b.has(a)) {
+const _ = /* @__PURE__ */ new Map();
+function Te(a, e) {
+  if (!_.has(a)) {
     const t = new m({
       source: new U({
         resource: a,
         ...e
       })
     }), r = () => {
-      b.get(a) === t && b.delete(a);
+      _.get(a) === t && _.delete(a);
     };
-    t.once("destroy", r), t.source.once("destroy", r), b.set(a, t);
+    t.once("destroy", r), t.source.once("destroy", r), _.set(a, t);
   }
-  return b.get(a);
+  return _.get(a);
 }
 function lt(a) {
   const e = a.colorTexture.source.resource;
   return globalThis.HTMLCanvasElement && e instanceof HTMLCanvasElement && document.body.contains(e);
 }
-const Te = class ke {
+const ye = class ke {
   /**
    * @param [descriptor] - Options for creating a render target.
    */
@@ -1064,7 +1066,6 @@ const Te = class ke {
    * This will ensure a depthStencil texture is created for this render target.
    * Most likely called by the mask system to make sure we have stencil buffer added.
    * @internal
-   * @ignore
    */
   ensureDepthStencilTexture() {
     this.depthStencilTexture || (this.depthStencilTexture = new T({
@@ -1089,7 +1090,7 @@ const Te = class ke {
     }), this.depthStencilTexture && (this.depthStencilTexture.destroy(), delete this.depthStencilTexture);
   }
 };
-Te.defaultOptions = {
+ye.defaultOptions = {
   /** the width of the RenderTarget */
   width: 0,
   /** the height of the RenderTarget */
@@ -1108,8 +1109,8 @@ Te.defaultOptions = {
   /** is this a root element, true if this is gl context owners render target */
   isRoot: !1
 };
-let I = Te;
-class Dt {
+let I = ye;
+class Et {
   constructor(e) {
     this.rootViewPort = new w(), this.viewport = new w(), this.onRenderTargetChange = new Ne("onRenderTargetChange"), this.projectionMatrix = new v(), this.defaultClearColor = [0, 0, 0, 0], this._renderSurfaceToRenderTargetHash = /* @__PURE__ */ new Map(), this._gpuRenderTargetHash = /* @__PURE__ */ Object.create(null), this._renderTargetStack = [], this._renderer = e, e.renderableGC.addManagedHash(this, "_gpuRenderTargetHash");
   }
@@ -1281,9 +1282,9 @@ class Dt {
   }
   _initRenderTarget(e) {
     let t = null;
-    return U.test(e) && (e = ye(e).source), e instanceof I ? t = e : e instanceof T && (t = new I({
+    return U.test(e) && (e = Te(e).source), e instanceof I ? t = e : e instanceof T && (t = new I({
       colorTextures: [e]
-    }), U.test(e.source.resource) && (t.isRoot = !0), e.once("destroy", () => {
+    }), e.source instanceof U && (t.isRoot = !0), e.once("destroy", () => {
       t.destroy(), this._renderSurfaceToRenderTargetHash.delete(e);
       const r = this._gpuRenderTargetHash[t.uid];
       r && (this._gpuRenderTargetHash[t.uid] = null, this.adaptor.destroyGpuRenderTarget(r));
@@ -1358,7 +1359,7 @@ function G(a, e) {
   }
 }
 const ut = new v();
-class Se {
+class Me {
   constructor(e) {
     this._renderer = e;
   }
@@ -1372,10 +1373,10 @@ class Se {
     this._renderer = null;
   }
   _addRenderableDirect(e, t) {
-    this._renderer.renderPipes.batch.break(t), e._batchableRenderGroup && (g.return(e._batchableRenderGroup), e._batchableRenderGroup = null), t.add(e);
+    this._renderer.renderPipes.batch.break(t), e._batchableRenderGroup && (S.return(e._batchableRenderGroup), e._batchableRenderGroup = null), t.add(e);
   }
   _addRenderableCacheAsTexture(e, t) {
-    const r = e._batchableRenderGroup ?? (e._batchableRenderGroup = g.get(pe));
+    const r = e._batchableRenderGroup ?? (e._batchableRenderGroup = S.get(pe));
     r.renderable = e.root, r.transform = e.root.relativeGroupTransform, r.texture = e.texture, r.bounds = e._textureBounds, t.add(e), this._renderer.renderPipes.batch.addToBatch(r, t);
   }
   _executeCacheAsTexture(e) {
@@ -1399,7 +1400,7 @@ class Se {
     }), G(e, this._renderer.renderPipes), this._renderer.globalUniforms.pop();
   }
 }
-Se.extension = {
+Me.extension = {
   type: [
     u.WebGLPipes,
     u.WebGPUPipes,
@@ -1407,13 +1408,13 @@ Se.extension = {
   ],
   name: "renderGroup"
 };
-function E(a, e) {
+function D(a, e) {
   e || (e = 0);
   for (let t = e; t < a.length && a[t]; t++)
     a[t] = null;
 }
 const dt = new P(), Q = le | ue | de;
-function Me(a, e = !1) {
+function Se(a, e = !1) {
   ct(a);
   const t = a.childrenToUpdate, r = a.updateTick++;
   for (const s in t) {
@@ -1422,11 +1423,11 @@ function Me(a, e = !1) {
       const c = o[d];
       c.parentRenderGroup === a && c.relativeRenderGroupDepth === n && we(c, r, 0);
     }
-    E(o, l), i.index = 0;
+    D(o, l), i.index = 0;
   }
   if (e)
     for (let s = 0; s < a.renderGroupChildren.length; s++)
-      Me(a.renderGroupChildren[s], e);
+      Se(a.renderGroupChildren[s], e);
 }
 function ct(a) {
   const e = a.root;
@@ -1517,20 +1518,20 @@ class Pe {
         const r = e.root.getLocalBounds();
         r.ceil();
         const s = e.texture;
-        e.texture && y.returnTexture(e.texture);
+        e.texture && b.returnTexture(e.texture);
         const n = this._renderer, i = e.textureOptions.resolution || n.view.resolution, o = e.textureOptions.antialias ?? n.view.antialias;
-        e.texture = y.getOptimalTexture(
+        e.texture = b.getOptimalTexture(
           r.width,
           r.height,
           i,
           o
         ), e._textureBounds || (e._textureBounds = new O()), e._textureBounds.copyFrom(r), s !== e.texture && e.renderGroupParent && (e.renderGroupParent.structureDidChange = !0);
       }
-    } else e.texture && (y.returnTexture(e.texture), e.texture = null);
+    } else e.texture && (b.returnTexture(e.texture), e.texture = null);
   }
   _updateRenderGroups(e) {
     const t = this._renderer, r = t.renderPipes;
-    if (e.runOnRender(t), e.instructionSet.renderPipes = r, e.structureDidChange ? E(e.childrenRenderablesToUpdate.list, 0) : ht(e, r), Me(e), e.structureDidChange ? (e.structureDidChange = !1, this._buildInstructions(e, t)) : this._updateRenderables(e), e.childrenRenderablesToUpdate.index = 0, t.renderPipes.batch.upload(e.instructionSet), !(e.isCachedAsTexture && !e.textureNeedsUpdate))
+    if (e.runOnRender(t), e.instructionSet.renderPipes = r, e.structureDidChange ? D(e.childrenRenderablesToUpdate.list, 0) : ht(e, r), Se(e), e.structureDidChange ? (e.structureDidChange = !1, this._buildInstructions(e, t)) : this._updateRenderables(e), e.childrenRenderablesToUpdate.index = 0, t.renderPipes.batch.upload(e.instructionSet), !(e.isCachedAsTexture && !e.textureNeedsUpdate))
       for (let s = 0; s < e.renderGroupChildren.length; s++)
         this._updateRenderGroups(e.renderGroupChildren[s]);
   }
@@ -1540,7 +1541,7 @@ class Pe {
       const n = t[s];
       n.didViewUpdate && e.updateRenderable(n);
     }
-    E(t, r);
+    D(t, r);
   }
   _buildInstructions(e, t) {
     const r = e.root, s = e.instructionSet;
@@ -1559,14 +1560,14 @@ Pe.extension = {
 };
 class Re {
   constructor(e) {
-    this._gpuSpriteHash = /* @__PURE__ */ Object.create(null), this._destroyRenderableBound = this.destroyRenderable.bind(this), this._renderer = e, this._renderer.renderableGC.addManagedHash(this, "_gpuSpriteHash");
+    this._renderer = e;
   }
   addRenderable(e, t) {
     const r = this._getGpuSprite(e);
     e.didViewUpdate && this._updateBatchableSprite(e, r), this._renderer.renderPipes.batch.addToBatch(r, t);
   }
   updateRenderable(e) {
-    const t = this._gpuSpriteHash[e.uid];
+    const t = this._getGpuSprite(e);
     e.didViewUpdate && this._updateBatchableSprite(e, t), t._batcher.updateElement(t);
   }
   validateRenderable(e) {
@@ -1576,24 +1577,18 @@ class Re {
       e._texture
     );
   }
-  destroyRenderable(e) {
-    const t = this._gpuSpriteHash[e.uid];
-    g.return(t), this._gpuSpriteHash[e.uid] = null, e.off("destroyed", this._destroyRenderableBound);
-  }
   _updateBatchableSprite(e, t) {
     t.bounds = e.visualBounds, t.texture = e._texture;
   }
   _getGpuSprite(e) {
-    return this._gpuSpriteHash[e.uid] || this._initGPUSprite(e);
+    return e._gpuData[this._renderer.uid] || this._initGPUSprite(e);
   }
   _initGPUSprite(e) {
-    const t = g.get(pe);
-    return t.renderable = e, t.transform = e.groupTransform, t.texture = e._texture, t.bounds = e.visualBounds, t.roundPixels = this._renderer._roundPixels | e._roundPixels, this._gpuSpriteHash[e.uid] = t, e.on("destroyed", this._destroyRenderableBound), t;
+    const t = new pe();
+    return t.renderable = e, t.transform = e.groupTransform, t.texture = e._texture, t.bounds = e.visualBounds, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._gpuData[this._renderer.uid] = t, t;
   }
   destroy() {
-    for (const e in this._gpuSpriteHash)
-      g.return(this._gpuSpriteHash[e]);
-    this._gpuSpriteHash = null, this._renderer = null;
+    this._renderer = null;
   }
 }
 Re.extension = {
@@ -1604,7 +1599,7 @@ Re.extension = {
   ],
   name: "sprite"
 };
-const L = class Be {
+const H = class Be {
   constructor() {
     this.clearBeforeRender = !0, this._backgroundColor = new ce(0), this.color = this._backgroundColor, this.alpha = 1;
   }
@@ -1636,12 +1631,11 @@ const L = class Be {
   /**
    * destroys the background system
    * @internal
-   * @ignore
    */
   destroy() {
   }
 };
-L.extension = {
+H.extension = {
   type: [
     u.WebGLSystem,
     u.WebGPUSystem,
@@ -1650,7 +1644,7 @@ L.extension = {
   name: "background",
   priority: 0
 };
-L.defaultOptions = {
+H.defaultOptions = {
   /**
    * {@link WebGLOptions.backgroundAlpha}
    * @default 1
@@ -1667,14 +1661,14 @@ L.defaultOptions = {
    */
   clearBeforeRender: !0
 };
-let pt = L;
-const k = {};
-D.handle(u.BlendMode, (a) => {
+let pt = H;
+const y = {};
+E.handle(u.BlendMode, (a) => {
   if (!a.name)
     throw new Error("BlendMode extension must have a name property");
-  k[a.name] = a.ref;
+  y[a.name] = a.ref;
 }, (a) => {
-  delete k[a.name];
+  delete y[a.name];
 });
 class Ue {
   constructor(e) {
@@ -1694,17 +1688,17 @@ class Ue {
       this._isAdvanced && this._renderableList.push(e);
       return;
     }
-    this._activeBlendMode = t, this._isAdvanced && this._endAdvancedBlendMode(r), this._isAdvanced = !!k[t], this._isAdvanced && (this._beginAdvancedBlendMode(r), this._renderableList.push(e));
+    this._activeBlendMode = t, this._isAdvanced && this._endAdvancedBlendMode(r), this._isAdvanced = !!y[t], this._isAdvanced && (this._beginAdvancedBlendMode(r), this._renderableList.push(e));
   }
   _beginAdvancedBlendMode(e) {
     this._renderer.renderPipes.batch.break(e);
     const t = this._activeBlendMode;
-    if (!k[t]) {
+    if (!y[t]) {
       ie(`Unable to assign BlendMode: '${t}'. You may want to include: import 'pixi.js/advanced-blend-modes'`);
       return;
     }
     let r = this._filterHash[t];
-    r || (r = this._filterHash[t] = new ne(), r.filters = [new k[t]()]);
+    r || (r = this._filterHash[t] = new ne(), r.filters = [new y[t]()]);
     const s = {
       renderPipeId: "filter",
       action: "pushFilter",
@@ -1724,7 +1718,6 @@ class Ue {
   /**
    * called when the instruction build process is starting this will reset internally to the default blend mode
    * @internal
-   * @ignore
    */
   buildStart() {
     this._isAdvanced = !1;
@@ -1734,15 +1727,11 @@ class Ue {
    * active, we add the final render instructions added to the instruction set
    * @param instructionSet - The instruction set we are adding to
    * @internal
-   * @ignore
    */
   buildEnd(e) {
     this._isAdvanced && this._endAdvancedBlendMode(e);
   }
-  /**
-   * @internal
-   * @ignore
-   */
+  /** @internal */
   destroy() {
     this._renderer = null, this._renderableList = null;
     for (const e in this._filterHash)
@@ -1777,18 +1766,71 @@ const R = {
     };
   }
   /**
-   * Will return a HTML Image of the target
-   * @param options - The options for creating the image, or the target to extract
-   * @returns - HTML Image of the target
+   * Creates an HTMLImageElement from a display object or texture.
+   * @param options - Options for creating the image, or the target to extract
+   * @returns Promise that resolves with the generated HTMLImageElement
+   * @example
+   * ```ts
+   * // Basic usage with a sprite
+   * const sprite = new Sprite(texture);
+   * const image = await renderer.extract.image(sprite);
+   * document.body.appendChild(image);
+   *
+   * // Advanced usage with options
+   * const image = await renderer.extract.image({
+   *     target: container,
+   *     format: 'webp',
+   *     quality: 0.8,
+   *     frame: new Rectangle(0, 0, 100, 100),
+   *     resolution: 2,
+   *     clearColor: '#ff0000',
+   *     antialias: true
+   * });
+   *
+   * // Extract directly from a texture
+   * const texture = Texture.from('myTexture.png');
+   * const image = await renderer.extract.image(texture);
+   * ```
+   * @see {@link ExtractImageOptions} For detailed options
+   * @see {@link ExtractSystem.base64} For base64 string output
+   * @see {@link ExtractSystem.canvas} For canvas output
+   * @category rendering
    */
   async image(e) {
     const t = new Image();
     return t.src = await this.base64(e), t;
   }
   /**
-   * Will return a base64 encoded string of this target. It works by calling
-   * `Extract.canvas` and then running toDataURL on that.
-   * @param options - The options for creating the image, or the target to extract
+   * Converts the target into a base64 encoded string.
+   *
+   * This method works by first creating
+   * a canvas using `Extract.canvas` and then converting it to a base64 string.
+   * @param options - The options for creating the base64 string, or the target to extract
+   * @returns Promise that resolves with the base64 encoded string
+   * @example
+   * ```ts
+   * // Basic usage with a sprite
+   * const sprite = new Sprite(texture);
+   * const base64 = await renderer.extract.base64(sprite);
+   * console.log(base64); // data:image/png;base64,...
+   *
+   * // Advanced usage with options
+   * const base64 = await renderer.extract.base64({
+   *     target: container,
+   *     format: 'webp',
+   *     quality: 0.8,
+   *     frame: new Rectangle(0, 0, 100, 100),
+   *     resolution: 2
+   * });
+   * ```
+   * @throws Will throw an error if the platform doesn't support any of:
+   * - ICanvas.toDataURL
+   * - ICanvas.toBlob
+   * - ICanvas.convertToBlob
+   * @see {@link ExtractImageOptions} For detailed options
+   * @see {@link ExtractSystem.canvas} For canvas output
+   * @see {@link ExtractSystem.image} For HTMLImage output
+   * @category rendering
    */
   async base64(e) {
     e = this._normalizeOptions(
@@ -1819,9 +1861,44 @@ const R = {
     throw new Error("Extract.base64() requires ICanvas.toDataURL, ICanvas.toBlob, or ICanvas.convertToBlob to be implemented");
   }
   /**
-   * Creates a Canvas element, renders this target to it and then returns it.
+   * Creates a Canvas element, renders the target to it and returns it.
+   * This method is useful for creating static images or when you need direct canvas access.
    * @param options - The options for creating the canvas, or the target to extract
-   * @returns - A Canvas element with the texture rendered on.
+   * @returns A Canvas element with the texture rendered on
+   * @example
+   * ```ts
+   * // Basic canvas extraction from a sprite
+   * const sprite = new Sprite(texture);
+   * const canvas = renderer.extract.canvas(sprite);
+   * document.body.appendChild(canvas);
+   *
+   * // Extract with custom region
+   * const canvas = renderer.extract.canvas({
+   *     target: container,
+   *     frame: new Rectangle(0, 0, 100, 100)
+   * });
+   *
+   * // Extract with high resolution
+   * const canvas = renderer.extract.canvas({
+   *     target: sprite,
+   *     resolution: 2,
+   *     clearColor: '#ff0000'
+   * });
+   *
+   * // Extract directly from a texture
+   * const texture = Texture.from('myTexture.png');
+   * const canvas = renderer.extract.canvas(texture);
+   *
+   * // Extract with anti-aliasing
+   * const canvas = renderer.extract.canvas({
+   *     target: graphics,
+   *     antialias: true
+   * });
+   * ```
+   * @see {@link ExtractOptions} For detailed options
+   * @see {@link ExtractSystem.image} For HTMLImage output
+   * @see {@link ExtractSystem.pixels} For raw pixel data
+   * @category rendering
    */
   canvas(e) {
     e = this._normalizeOptions(e);
@@ -1832,10 +1909,34 @@ const R = {
     return s.destroy(!0), n;
   }
   /**
-   * Will return a one-dimensional array containing the pixel data of the entire texture in RGBA
-   * order, with integer values between 0 and 255 (included).
+   * Returns a one-dimensional array containing the pixel data of the entire texture in RGBA order,
+   * with integer values between 0 and 255 (inclusive).
+   * > [!NOE] The returned array is a flat Uint8Array where every 4 values represent RGBA
    * @param options - The options for extracting the image, or the target to extract
-   * @returns - One-dimensional array containing the pixel data of the entire texture
+   * @returns One-dimensional Uint8Array containing the pixel data in RGBA format
+   * @example
+   * ```ts
+   * // Basic pixel extraction
+   * const sprite = new Sprite(texture);
+   * const pixels = renderer.extract.pixels(sprite);
+   * console.log(pixels[0], pixels[1], pixels[2], pixels[3]); // R,G,B,A values
+   *
+   * // Extract with custom region
+   * const pixels = renderer.extract.pixels({
+   *     target: sprite,
+   *     frame: new Rectangle(0, 0, 100, 100)
+   * });
+   *
+   * // Extract with high resolution
+   * const pixels = renderer.extract.pixels({
+   *     target: sprite,
+   *     resolution: 2
+   * });
+   * ```
+   * @see {@link ExtractOptions} For detailed options
+   * @see {@link ExtractSystem.canvas} For canvas output
+   * @see {@link ExtractSystem.image} For image output
+   * @category rendering
    */
   pixels(e) {
     e = this._normalizeOptions(e);
@@ -1843,16 +1944,94 @@ const R = {
     return t instanceof P && s.destroy(!0), n;
   }
   /**
-   * Will return a texture of the target
+   * Creates a texture from a display object or existing texture.
+   *
+   * This is useful for creating
+   * reusable textures from rendered content or making copies of existing textures.
+   * > [!NOTE] The returned texture should be destroyed when no longer needed
    * @param options - The options for creating the texture, or the target to extract
-   * @returns - A texture of the target
+   * @returns A new texture containing the extracted content
+   * @example
+   * ```ts
+   * // Basic texture extraction from a sprite
+   * const sprite = new Sprite(texture);
+   * const extractedTexture = renderer.extract.texture(sprite);
+   *
+   * // Extract with custom region
+   * const regionTexture = renderer.extract.texture({
+   *     target: container,
+   *     frame: new Rectangle(0, 0, 100, 100)
+   * });
+   *
+   * // Extract with high resolution
+   * const hiResTexture = renderer.extract.texture({
+   *     target: sprite,
+   *     resolution: 2,
+   *     clearColor: '#ff0000'
+   * });
+   *
+   * // Create a new sprite from extracted texture
+   * const newSprite = new Sprite(
+   *     renderer.extract.texture({
+   *         target: graphics,
+   *         antialias: true
+   *     })
+   * );
+   *
+   * // Clean up when done
+   * extractedTexture.destroy(true);
+   * ```
+   * @see {@link ExtractOptions} For detailed options
+   * @see {@link Texture} For texture management
+   * @see {@link GenerateTextureSystem} For texture generation
+   * @category rendering
    */
   texture(e) {
     return e = this._normalizeOptions(e), e.target instanceof m ? e.target : this._renderer.textureGenerator.generateTexture(e);
   }
   /**
-   * Will extract a HTMLImage of the target and download it
+   * Extracts and downloads content from the renderer as an image file.
+   * This is a convenient way to save screenshots or export rendered content.
+   * > [!NOTE] The download will use PNG format regardless of the filename extension
    * @param options - The options for downloading and extracting the image, or the target to extract
+   * @example
+   * ```ts
+   * // Basic download with default filename
+   * const sprite = new Sprite(texture);
+   * renderer.extract.download(sprite); // Downloads as 'image.png'
+   *
+   * // Download with custom filename
+   * renderer.extract.download({
+   *     target: sprite,
+   *     filename: 'screenshot.png'
+   * });
+   *
+   * // Download with custom region
+   * renderer.extract.download({
+   *     target: container,
+   *     filename: 'region.png',
+   *     frame: new Rectangle(0, 0, 100, 100)
+   * });
+   *
+   * // Download with high resolution and background
+   * renderer.extract.download({
+   *     target: stage,
+   *     filename: 'hd-screenshot.png',
+   *     resolution: 2,
+   *     clearColor: '#ff0000'
+   * });
+   *
+   * // Download with anti-aliasing
+   * renderer.extract.download({
+   *     target: graphics,
+   *     filename: 'smooth.png',
+   *     antialias: true
+   * });
+   * ```
+   * @see {@link ExtractDownloadOptions} For detailed options
+   * @see {@link ExtractSystem.image} For creating images without download
+   * @see {@link ExtractSystem.canvas} For canvas output
+   * @category rendering
    */
   download(e) {
     e = this._normalizeOptions(e);
@@ -1861,7 +2040,19 @@ const R = {
   }
   /**
    * Logs the target to the console as an image. This is a useful way to debug what's happening in the renderer.
+   * The image will be displayed in the browser's console using CSS background images.
    * @param options - The options for logging the image, or the target to log
+   * @param options.width - The width of the logged image preview in the console (in pixels)
+   * @example
+   * ```ts
+   * // Basic usage
+   * const sprite = new Sprite(texture);
+   * renderer.extract.log(sprite);
+   * ```
+   * @see {@link ExtractSystem.canvas} For getting raw canvas output
+   * @see {@link ExtractSystem.pixels} For raw pixel data
+   * @category rendering
+   * @advanced
    */
   log(e) {
     const t = e.width ?? 200;
@@ -1888,9 +2079,7 @@ z.extension = {
   name: "extract"
 };
 z.defaultImageOptions = {
-  /** The format of the image. */
   format: "png",
-  /** The quality of the image. */
   quality: 1
 };
 let mt = z;
@@ -1911,21 +2100,46 @@ class W extends m {
     return this.source.resize(e, t, r), this;
   }
 }
-const vt = new w(), gt = new O(), xt = [0, 0, 0, 0];
+const vt = new w(), xt = new O(), gt = [0, 0, 0, 0];
 class Ie {
   constructor(e) {
     this._renderer = e;
   }
   /**
-   * A Useful function that returns a texture of the display object that can then be used to create sprites
-   * This can be quite useful if your container is complicated and needs to be reused multiple times.
-   * @param {GenerateTextureOptions | Container} options - Generate texture options.
-   * @param {Container} [options.container] - If not given, the renderer's resolution is used.
-   * @param {Rectangle} options.region - The region of the container, that shall be rendered,
-   * @param {number} [options.resolution] - The resolution of the texture being generated.
-   *        if no region is specified, defaults to the local bounds of the container.
-   * @param {GenerateTextureSourceOptions} [options.textureSourceOptions] - Texture options for GPU.
-   * @returns a shiny new texture of the container passed in
+   * Creates a texture from a display object that can be used for creating sprites and other textures.
+   * This is particularly useful for optimizing performance when a complex container needs to be reused.
+   * @param options - Generate texture options or a container to convert to texture
+   * @returns A new RenderTexture containing the rendered display object
+   * @example
+   * ```ts
+   * // Basic usage with a container
+   * const container = new Container();
+   * container.addChild(
+   *     new Graphics()
+   *         .circle(0, 0, 50)
+   *         .fill('red')
+   * );
+   *
+   * const texture = renderer.textureGenerator.generateTexture(container);
+   *
+   * // Advanced usage with options
+   * const texture = renderer.textureGenerator.generateTexture({
+   *     target: container,
+   *     frame: new Rectangle(0, 0, 100, 100), // Specific region
+   *     resolution: 2,                        // High DPI
+   *     clearColor: '#ff0000',               // Red background
+   *     antialias: true                      // Smooth edges
+   * });
+   *
+   * // Create a sprite from the generated texture
+   * const sprite = new Sprite(texture);
+   *
+   * // Clean up when done
+   * texture.destroy(true);
+   * ```
+   * @see {@link GenerateTextureOptions} For detailed texture generation options
+   * @see {@link RenderTexture} For the type of texture created
+   * @category rendering
    */
   generateTexture(e) {
     var d;
@@ -1937,8 +2151,8 @@ class Ie {
     });
     const t = e.resolution || this._renderer.resolution, r = e.antialias || this._renderer.view.antialias, s = e.target;
     let n = e.clearColor;
-    n ? n = Array.isArray(n) && n.length === 4 ? n : ce.shared.setValue(n).toArray() : n = xt;
-    const i = ((d = e.frame) == null ? void 0 : d.copyTo(vt)) || $e(s, gt).rectangle;
+    n ? n = Array.isArray(n) && n.length === 4 ? n : ce.shared.setValue(n).toArray() : n = gt;
+    const i = ((d = e.frame) == null ? void 0 : d.copyTo(vt)) || $e(s, xt).rectangle;
     i.width = Math.max(i.width, 1 / t) | 0, i.height = Math.max(i.height, 1 / t) | 0;
     const o = W.create({
       ...e.textureSourceOptions,
@@ -2048,7 +2262,7 @@ Ge.extension = {
   name: "globalUniforms"
 };
 let _t = 1;
-class Ee {
+class De {
   constructor() {
     this._tasks = [], this._offset = 0;
   }
@@ -2104,13 +2318,12 @@ class Ee {
   /**
    * Destroys the scheduler system and removes all tasks.
    * @internal
-   * @ignore
    */
   destroy() {
     Y.system.remove(this._update, this), this._tasks.length = 0;
   }
 }
-Ee.extension = {
+De.extension = {
   type: [
     u.WebGLSystem,
     u.WebGPUSystem,
@@ -2167,7 +2380,7 @@ V.defaultOptions = {
   /** {@link WebGLOptions.hello} */
   hello: !1
 };
-function yt(a) {
+function Tt(a) {
   let e = !1;
   for (const r in a)
     if (a[r] == null) {
@@ -2183,14 +2396,14 @@ function yt(a) {
   }
   return t;
 }
-function Tt(a) {
+function yt(a) {
   let e = 0;
   for (let t = 0; t < a.length; t++)
     a[t] == null ? e++ : a[t - e] = a[t];
   return a.length -= e, a;
 }
 let kt = 0;
-const N = class De {
+const N = class Ee {
   /**
    * Creates a new RenderableGCSystem instance.
    * @param renderer - The renderer this garbage collection system works for
@@ -2203,7 +2416,7 @@ const N = class De {
    * @param options - Configuration options for the renderer
    */
   init(e) {
-    e = { ...De.defaultOptions, ...e }, this.maxUnusedTime = e.renderableGCMaxUnusedTime, this._frequency = e.renderableGCFrequency, this.enabled = e.renderableGCActive;
+    e = { ...Ee.defaultOptions, ...e }, this.maxUnusedTime = e.renderableGCMaxUnusedTime, this._frequency = e.renderableGCFrequency, this.enabled = e.renderableGCActive;
   }
   /**
    * Gets whether the garbage collection system is currently enabled.
@@ -2225,13 +2438,13 @@ const N = class De {
     ), this._hashHandler = this._renderer.scheduler.repeat(
       () => {
         for (const t of this._managedHashes)
-          t.context[t.hash] = yt(t.context[t.hash]);
+          t.context[t.hash] = Tt(t.context[t.hash]);
       },
       this._frequency
     ), this._arrayHandler = this._renderer.scheduler.repeat(
       () => {
         for (const t of this._managedArrays)
-          Tt(t.context[t.hash]);
+          yt(t.context[t.hash]);
       },
       this._frequency
     )) : (this._renderer.scheduler.cancel(this._handler), this._renderer.scheduler.cancel(this._hashHandler), this._renderer.scheduler.cancel(this._arrayHandler)));
@@ -2380,7 +2593,7 @@ j.defaultOptions = {
   textureGCActive: !0,
   /**
    * @deprecated since 8.3.0
-   * @see {@link TextureGCSystem.textureGCMaxIdle}
+   * @see {@link TextureGCSystemOptions.textureGCMaxIdle}
    */
   textureGCAMaxIdle: null,
   /**
@@ -2394,12 +2607,12 @@ j.defaultOptions = {
    */
   textureGCCheckCountMax: 600
 };
-let St = j;
+let Mt = j;
 const $ = class Fe {
   /**
    * Whether CSS dimensions of canvas view should be resized to screen dimensions automatically.
    * This is only supported for HTMLCanvasElement and will be ignored if the canvas is an OffscreenCanvas.
-   * @member {boolean}
+   * @type {boolean}
    */
   get autoDensity() {
     return this.texture.source.autoDensity;
@@ -2426,7 +2639,7 @@ const $ = class Fe {
     e = {
       ...Fe.defaultOptions,
       ...e
-    }, e.view && (Ye(Je, "ViewSystem.view has been renamed to ViewSystem.canvas"), e.canvas = e.view), this.screen = new w(0, 0, e.width, e.height), this.canvas = e.canvas || he.get().createCanvas(), this.antialias = !!e.antialias, this.texture = ye(this.canvas, e), this.renderTarget = new I({
+    }, e.view && (Ye(Je, "ViewSystem.view has been renamed to ViewSystem.canvas"), e.canvas = e.view), this.screen = new w(0, 0, e.width, e.height), this.canvas = e.canvas || he.get().createCanvas(), this.antialias = !!e.antialias, this.texture = Te(this.canvas, e), this.renderTarget = new I({
       colorTextures: [this.texture],
       depth: !!e.depth,
       isRoot: !0
@@ -2444,7 +2657,10 @@ const $ = class Fe {
   /**
    * Destroys this System and optionally removes the canvas from the dom.
    * @param {options | false} options - The options for destroying the view, or "false".
-   * @param options.removeView - Whether to remove the view element from the DOM. Defaults to `false`.
+   * @example
+   * viewSystem.destroy();
+   * viewSystem.destroy(true);
+   * viewSystem.destroy({ removeView: true });
    */
   destroy(e = !1) {
     (typeof e == "boolean" ? e : !!(e != null && e.removeView)) && this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas);
@@ -2481,41 +2697,41 @@ $.defaultOptions = {
    */
   antialias: !1
 };
-let Mt = $;
+let St = $;
 const Ft = [
   pt,
   Ge,
   V,
-  Mt,
-  Pe,
   St,
+  Pe,
+  Mt,
   Ie,
   mt,
   Xe,
   Ct,
-  Ee
-], Ht = [
+  De
+], Lt = [
   Ue,
-  ge,
-  Re,
-  Se,
   xe,
+  Re,
+  Me,
+  ge,
   be,
   _e,
   Ce
 ];
 export {
   Ot as B,
-  _ as G,
-  Dt as R,
+  g as G,
+  Et as R,
   Ft as S,
   It as U,
-  Ht as a,
+  Lt as a,
   it as b,
   Gt as c,
-  S as d,
+  C as d,
   At as e,
   Ut as f,
   Bt as t,
-  Et as u
+  Dt as u
 };