@omnimedia/omnitool 1.1.0-8 → 1.1.0-80

package/s/timeline/types.ts

@@ -1,4 +1,13 @@
-export type Interpolation = "linear" | "catmullRom"
+import {Item, VisualAnimatableItem} from "./parts/item.js"
+
+export type Interpolation =
+	| "linear"
+	| "ease"
+	| "easeIn"
+	| "easeOut"
+	| "bounce"
+	| "catmullRom"
+
 export type Keyframe<Value = number> = [time: number, value: Value]
 export type Keyframes<Value = number> = Keyframe<Value>[]
 export type Vec2 = [x: number, y: number]
@@ -14,16 +23,32 @@ export type Anim<T> = {
   track: T
 }
 
-export type Animations = Anim<TrackTransform>
-
 export type TrackTransform = {
 	position: TrackVec2
 	scale: TrackVec2
 	rotation: Keyframes
 }
 
+export type ScalarAnimation = Anim<Keyframes>
+export type Vec2Animation = Anim<TrackVec2>
+export type TransformAnimation = Anim<TrackTransform>
+export type VisualAnimations = {
+	opacity?: ScalarAnimation
+}
+export interface AnimateAction {
+	<T extends VisualAnimatableItem>(
+		item: T,
+		terp: Interpolation,
+		track: Keyframes
+	): T
+	make(terp: Interpolation, track: Keyframes): Item.Animation
+}
+
+// export type Animations = Anim<TrackTransform>
+
 export type TransformOptions = {
   position?: Vec2
   scale?: Vec2
   rotation?: number
 }
+

package/s/timeline/utils/anim.ts

@@ -0,0 +1,71 @@
+
+import {resolveTerp} from "./terps.js"
+import {Item, Kind} from "../parts/item.js"
+import {Anim, Keyframes, ScalarAnimation, TrackTransform, Transform} from "../types.js"
+
+const resolveScalar =(
+	time: number,
+	keys: Keyframes,
+	terp: Anim<Keyframes>["terp"],
+): number => {
+	if (keys.length === 0)
+		return 0
+
+	if (keys.length === 1)
+		return keys[0][1]
+
+	const sorted = [...keys].sort((a, b) => a[0] - b[0])
+
+	if (time <= sorted[0][0])
+		return sorted[0][1]
+
+	const last = sorted[sorted.length - 1]
+	if (time >= last[0])
+		return last[1]
+
+	let index = 0
+	for (let i = 0; i < sorted.length - 1; i++) {
+		const a = sorted[i]
+		const b = sorted[i + 1]
+		if (time >= a[0] && time <= b[0]) {
+			index = i
+			break
+		}
+	}
+
+	const [t2] = sorted[index]
+	const [t3] = sorted[index + 1]
+	const span = t3 - t2
+	const x = span === 0 ? 0 : (time - t2) / span
+
+	return resolveTerp(terp, x, sorted, index)
+}
+
+export const resolveTransformAnimation =(
+	time: number,
+	anim: Anim<TrackTransform>,
+): Transform => ([
+	[
+		resolveScalar(time, anim.track.position.x, anim.terp),
+		resolveScalar(time, anim.track.position.y, anim.terp),
+	],
+	[
+		resolveScalar(time, anim.track.scale.x, anim.terp),
+		resolveScalar(time, anim.track.scale.y, anim.terp),
+	],
+	resolveScalar(time, anim.track.rotation, anim.terp),
+])
+
+export const resolveScalarAnimation =(
+	time: number,
+	anim: ScalarAnimation,
+): number => resolveScalar(time, anim.track, anim.terp)
+
+export const resolveSpatialTransform =(
+	spatial: Item.Spatial | Item.AnimatedSpatial,
+	time: number,
+): Transform =>
+	spatial.kind === Kind.AnimatedSpatial
+		? resolveTransformAnimation(time, spatial.anim)
+		: spatial.transform
+

package/s/timeline/utils/checksum.ts

@@ -1,11 +1,13 @@
 
 import {Hex, Thumbprint} from "@e280/stz"
 
+import {Hash} from "../parts/basics.js"
+
 export class Checksum {
 	constructor(
 		public data: Uint8Array,
 		public bytes: Uint8Array,
-		public hash: string,
+		public hash: Hash,
 		public nickname: string,
 	) {}
 

package/s/timeline/utils/datafile.ts

@@ -3,19 +3,30 @@ import {Checksum} from "./checksum.js"
 
 export class Datafile {
 	constructor(
+		public url: string,
 		public bytes: Uint8Array,
+		public blob: Blob,
 		public filename: string,
 		public checksum: Checksum,
 	) {}
 
-	static async make(bytes: Uint8Array, name?: string) {
+	static async make(file: Blob, name?: string) {
+		const buffer = await file.arrayBuffer()
+		const bytes = new Uint8Array(buffer)
 		const checksum = await Checksum.make(bytes)
 		const filename = name ?? checksum.nickname
-		return new this(bytes, filename, checksum)
+		const url = URL.createObjectURL(file)
+		return new this(url, bytes, file, filename, checksum)
 	}
 
-	static async load(_path: string): Promise<Datafile> {
-		throw new Error("TODO implement")
+	static async load(path: string) {
+		// const file = await fetch(path)
+		// const buffer = await file.arrayBuffer()
+		// const bytes = new Uint8Array(buffer)
+		// const filename =  file?.headers.get('Content-Disposition')?.split('filename=')[1] ?? "file"
+		// console.log(filename)
+		// const checksum = await Checksum.make(bytes)
+		// return new this(path, bytes, filename, checksum)
 	}
 }
 

package/s/timeline/utils/dummy-data.ts

@@ -1,7 +1,7 @@
 
 import {Datafile} from "./datafile.js"
 
-export const dummyData = () => Datafile.make(
-	new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF])
-)
+// export const dummyData = () => Datafile.make(
+// 	new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF])
+// )
 

package/s/timeline/utils/matrix.ts

@@ -29,5 +29,26 @@ export const mul6 = (local: Mat6, parent: Mat6): Mat6 => {
 	]
 }
 
+export const mat6ToTransform = (mat: Mat6Obj): Transform => {
+	const scaleX = Math.hypot(mat.a, mat.b)
+	const scaleY = Math.hypot(mat.c, mat.d)
+	const rotation = Math.atan2(mat.b, mat.a) * (180 / Math.PI)
+
+	return [
+		[mat.tx, mat.ty],
+		[scaleX, scaleY],
+		rotation,
+	]
+}
+
+export interface Mat6Obj {
+	a: number
+	b: number
+	c: number
+	d: number
+	tx: number
+	ty: number
+}
+
 export const I6: Mat6 = [1, 0, 0, 1, 0, 0]
 export type Mat6 = [a: number, b: number, c: number, d: number, tx: number, ty: number]

package/s/timeline/utils/terps.ts

@@ -0,0 +1,81 @@
+
+import {Interpolation, Keyframes} from "../types.js"
+
+type EasingFn = (x: number, a: number, b: number) => number
+
+class TerpKeys {
+	constructor(
+		private keys: Keyframes,
+		private index: number,
+	) {}
+
+	near(offset: number): number {
+		const next = this.keys[Math.max(0, Math.min(this.keys.length - 1, this.index + offset))]
+		return next[1]
+	}
+}
+
+type TerpFn = (x: number, keys: TerpKeys) => number
+
+const asTerp = (fn: TerpFn): TerpFn => fn
+
+const fromEasingFn = (easing: EasingFn): TerpFn =>
+	asTerp((x, keys) => easing(x, keys.near(0), keys.near(1)))
+
+const lerp = (x: number, a: number, b: number) => a + (b - a) * x
+
+export const terps: Record<Interpolation, TerpFn> = {
+	linear: fromEasingFn(lerp),
+
+	ease: fromEasingFn((x, a, b) => {
+		const eased = x < 0.5
+			? 4 * x * x * x
+			: 1 - Math.pow(-2 * x + 2, 3) / 2
+		return lerp(eased, a, b)
+	}),
+
+	easeIn: fromEasingFn((x, a, b) => lerp(x * x * x, a, b)),
+
+	easeOut: fromEasingFn((x, a, b) => lerp(1 - Math.pow(1 - x, 3), a, b)),
+
+	bounce: fromEasingFn((x, a, b) => {
+		const n1 = 7.5625
+		const d1 = 2.75
+		const eased = x < 1 / d1
+			? n1 * x * x
+			: x < 2 / d1
+				? n1 * (x - 1.5 / d1) ** 2 + 0.75
+				: x < 2.5 / d1
+					? n1 * (x - 2.25 / d1) ** 2 + 0.9375
+					: n1 * (x - 2.625 / d1) ** 2 + 0.984375
+		return lerp(eased, a, b)
+	}),
+
+	catmullRom: asTerp((x, keys) => {
+		const p1 = keys.near(-1)
+		const p2 = keys.near(0)
+		const p3 = keys.near(1)
+		const p4 = keys.near(2)
+		const x2 = x * x
+		const x3 = x2 * x
+		return 0.5 * (
+			(2 * p2) +
+			(-p1 + p3) * x +
+			(2 * p1 - 5 * p2 + 4 * p3 - p4) * x2 +
+			(-p1 + 3 * p2 - 3 * p3 + p4) * x3
+		)
+	}),
+}
+
+export const resolveTerp =(
+	terp: Interpolation,
+	x: number,
+	keys: Keyframes,
+	index: number,
+): number => {
+	const fn = terps[terp]
+	if (!fn)
+		throw new Error(`unknown terp "${terp}"`)
+
+	return fn(x, new TerpKeys(keys, index))
+}

package/s/units/fps.ts

@@ -0,0 +1,8 @@
+declare const FpsBrand: unique symbol
+
+export type Fps = number & {
+	readonly [FpsBrand]: "fps"
+}
+
+export const fps = (value: number): Fps =>
+	value as Fps

package/s/units/ms.ts

@@ -0,0 +1,8 @@
+declare const MsBrand: unique symbol
+
+export type Ms = number & {
+	readonly [MsBrand]: "ms"
+}
+
+export const ms = (value: number): Ms =>
+	value as Ms

package/s/units/seconds.ts

@@ -0,0 +1,8 @@
+declare const SecondsBrand: unique symbol
+
+export type Seconds = number & {
+	readonly [SecondsBrand]: "s"
+}
+
+export const seconds = (value: number): Seconds =>
+	value as Seconds

package/x/WebGLRenderer-4CHIZDHY.js

@@ -0,0 +1,2 @@
+import{a}from"./chunk-KCMVLWBS.js";import"./chunk-VCUJJYRJ.js";import"./chunk-XNIZ4L5W.js";export{a as WebGLRenderer};
+//# sourceMappingURL=WebGLRenderer-4CHIZDHY.js.map

package/x/WebGLRenderer-4CHIZDHY.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/x/WebGPURenderer-O6WXU2QR.js

@@ -0,0 +1,2 @@
+import{a}from"./chunk-IAWJKNX5.js";import"./chunk-23FOBGX6.js";import"./chunk-VCUJJYRJ.js";import"./chunk-XNIZ4L5W.js";export{a as WebGPURenderer};
+//# sourceMappingURL=WebGPURenderer-O6WXU2QR.js.map

package/x/WebGPURenderer-O6WXU2QR.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/x/browserAll-WNIOTNNP.js

@@ -0,0 +1,2 @@
+import{a as i,b as o,c as m,d as p,e}from"./chunk-ZLGNQFUI.js";import"./chunk-MR32SQ27.js";import"./chunk-73XOWA4F.js";import"./chunk-23FOBGX6.js";import{P as t,e as r}from"./chunk-XNIZ4L5W.js";r.add(i);r.mixin(t,o);r.add(m);r.mixin(t,p);r.add(e);
+//# sourceMappingURL=browserAll-WNIOTNNP.js.map

package/x/browserAll-WNIOTNNP.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../node_modules/pixi.js/src/accessibility/init.ts", "../node_modules/pixi.js/src/events/init.ts", "../node_modules/pixi.js/src/dom/init.ts"],
+  "sourcesContent": ["import { extensions } from '../extensions/Extensions';\nimport { Container } from '../scene/container/Container';\nimport { AccessibilitySystem } from './AccessibilitySystem';\nimport { accessibilityTarget } from './accessibilityTarget';\n\nextensions.add(AccessibilitySystem);\nextensions.mixin(Container, accessibilityTarget);\n", "import { extensions } from '../extensions/Extensions';\nimport { Container } from '../scene/container/Container';\nimport { EventSystem } from './EventSystem';\nimport { FederatedContainer } from './FederatedEventTarget';\n\nextensions.add(EventSystem);\nextensions.mixin(Container, FederatedContainer);\n", "import { extensions } from '../extensions/Extensions';\nimport { DOMPipe } from './DOMPipe';\n\nexport * from './index';\n\nextensions.add(DOMPipe);\n"],
+  "mappings": "kMAKAA,EAAW,IAAIC,CAAmB,EAClCD,EAAW,MAAME,EAAWC,CAAmB,ECD/CC,EAAW,IAAIC,CAAW,EAC1BD,EAAW,MAAME,EAAWC,CAAkB,ECD9CC,EAAW,IAAIC,CAAO",
+  "names": ["extensions", "AccessibilitySystem", "Container", "accessibilityTarget", "extensions", "EventSystem", "Container", "FederatedContainer", "extensions", "DOMPipe"]
+}

package/x/chunk-23FOBGX6.js

@@ -0,0 +1,2 @@
+import{D as a,J as f,T as v,X as x,q as p}from"./chunk-XNIZ4L5W.js";var h={};function G(c,t,r){let e=2166136261;for(let o=0;o<t;o++)e^=c[o].uid,e=Math.imul(e,16777619),e>>>=0;return h[e]||d(c,t,e,r)}function d(c,t,r,e){let o={},s=0;for(let n=0;n<e;n++){let i=n<t?c[n]:f.EMPTY.source;o[s++]=i.source,o[s++]=i.style}let l=new x(o);return h[r]=l,l}var u=class{constructor(t){this._canvasPool=Object.create(null),this.canvasOptions=t||{},this.enableFullScreen=!1}_createCanvasAndContext(t,r){let e=v.get().createCanvas();e.width=t,e.height=r;let o=e.getContext("2d");return{canvas:e,context:o}}getOptimalCanvasAndContext(t,r,e=1){t=Math.ceil(t*e-1e-6),r=Math.ceil(r*e-1e-6),t=a(t),r=a(r);let o=(t<<17)+(r<<1);this._canvasPool[o]||(this._canvasPool[o]=[]);let s=this._canvasPool[o].pop();return s||(s=this._createCanvasAndContext(t,r)),s}returnCanvasAndContext(t){let r=t.canvas,{width:e,height:o}=r,s=(e<<17)+(o<<1);t.context.resetTransform(),t.context.clearRect(0,0,e,o),this._canvasPool[s].push(t)}clear(){this._canvasPool={}}},P=new u;p.register(P);export{G as a,P as b};
+//# sourceMappingURL=chunk-23FOBGX6.js.map

package/x/chunk-23FOBGX6.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../node_modules/pixi.js/src/rendering/batcher/gpu/getTextureBatchBindGroup.ts", "../node_modules/pixi.js/src/rendering/renderers/shared/texture/CanvasPool.ts"],
+  "sourcesContent": ["import { BindGroup } from '../../renderers/gpu/shader/BindGroup';\nimport { Texture } from '../../renderers/shared/texture/Texture';\n\nimport type { TextureSource } from '../../renderers/shared/texture/sources/TextureSource';\n\nconst cachedGroups: Record<number, BindGroup> = {};\n\n/**\n * @param textures\n * @param size\n * @param maxTextures\n * @internal\n */\nexport function getTextureBatchBindGroup(textures: TextureSource[], size: number, maxTextures: number)\n{\n    let uid = 2166136261; // FNV-1a 32-bit offset basis\n\n    for (let i = 0; i < size; i++)\n    {\n        uid ^= textures[i].uid;\n        uid = Math.imul(uid, 16777619);\n        uid >>>= 0;\n    }\n\n    return cachedGroups[uid] || generateTextureBatchBindGroup(textures, size, uid, maxTextures);\n}\n\nfunction generateTextureBatchBindGroup(textures: TextureSource[], size: number, key: number, maxTextures: number): BindGroup\n{\n    const bindGroupResources: Record<string, any> = {};\n\n    let bindIndex = 0;\n\n    for (let i = 0; i < maxTextures; i++)\n    {\n        const texture = i < size ? textures[i] : Texture.EMPTY.source;\n\n        bindGroupResources[bindIndex++] = texture.source;\n        bindGroupResources[bindIndex++] = texture.style;\n    }\n\n    // pad out with empty textures\n    const bindGroup = new BindGroup(bindGroupResources);\n\n    cachedGroups[key] = bindGroup;\n\n    return bindGroup;\n}\n\n", "import { DOMAdapter } from '../../../../environment/adapter';\nimport { nextPow2 } from '../../../../maths/misc/pow2';\nimport { GlobalResourceRegistry } from '../../../../utils/pool/GlobalResourceRegistry';\n\nimport type { ICanvas, ICanvasRenderingContext2DSettings } from '../../../../environment/canvas/ICanvas';\nimport type { ICanvasRenderingContext2D } from '../../../../environment/canvas/ICanvasRenderingContext2D';\n\n/**\n * A utility type that represents a canvas and its rendering context.\n * @category rendering\n * @internal\n */\nexport interface CanvasAndContext\n{\n    /** The canvas element. */\n    canvas: ICanvas;\n    /** The rendering context of the canvas. */\n    context: ICanvasRenderingContext2D;\n}\n\n/**\n * CanvasPool is a utility class that manages a pool of reusable canvas elements\n * @category rendering\n * @internal\n */\nexport class CanvasPoolClass\n{\n    public canvasOptions: ICanvasRenderingContext2DSettings;\n\n    /**\n     * Allow renderTextures of the same size as screen, not just pow2\n     *\n     * Automatically sets to true after `setScreenSize`\n     * @default false\n     */\n    public enableFullScreen: boolean;\n    private _canvasPool: {[x in string | number]: CanvasAndContext[]};\n\n    constructor(canvasOptions?: ICanvasRenderingContext2DSettings)\n    {\n        this._canvasPool = Object.create(null);\n        this.canvasOptions = canvasOptions || {};\n        this.enableFullScreen = false;\n    }\n\n    /**\n     * Creates texture with params that were specified in pool constructor.\n     * @param pixelWidth - Width of texture in pixels.\n     * @param pixelHeight - Height of texture in pixels.\n     */\n    private _createCanvasAndContext(pixelWidth: number, pixelHeight: number): CanvasAndContext\n    {\n        const canvas = DOMAdapter.get().createCanvas();\n\n        canvas.width = pixelWidth;\n        canvas.height = pixelHeight;\n\n        const context = canvas.getContext('2d');\n\n        return { canvas, context };\n    }\n\n    /**\n     * Gets a Power-of-Two render texture or fullScreen texture\n     * @param minWidth - The minimum width of the render texture.\n     * @param minHeight - The minimum height of the render texture.\n     * @param resolution - The resolution of the render texture.\n     * @returns The new render texture.\n     */\n    public getOptimalCanvasAndContext(minWidth: number, minHeight: number, resolution = 1): CanvasAndContext\n    {\n        minWidth = Math.ceil((minWidth * resolution) - 1e-6);\n        minHeight = Math.ceil((minHeight * resolution) - 1e-6);\n        minWidth = nextPow2(minWidth);\n        minHeight = nextPow2(minHeight);\n\n        const key = (minWidth << 17) + (minHeight << 1);\n\n        if (!this._canvasPool[key])\n        {\n            this._canvasPool[key] = [];\n        }\n\n        let canvasAndContext = this._canvasPool[key].pop();\n\n        if (!canvasAndContext)\n        {\n            canvasAndContext = this._createCanvasAndContext(minWidth, minHeight);\n        }\n\n        return canvasAndContext;\n    }\n\n    /**\n     * Place a render texture back into the pool.\n     * @param canvasAndContext\n     */\n    public returnCanvasAndContext(canvasAndContext: CanvasAndContext): void\n    {\n        const canvas = canvasAndContext.canvas;\n        const { width, height } = canvas;\n\n        const key = (width << 17) + (height << 1);\n\n        canvasAndContext.context.resetTransform();\n        canvasAndContext.context.clearRect(0, 0, width, height);\n\n        this._canvasPool[key].push(canvasAndContext);\n    }\n\n    public clear(): void\n    {\n        this._canvasPool = {};\n    }\n}\n\n/**\n * CanvasPool is a utility class that manages a pool of reusable canvas elements\n * @category rendering\n * @internal\n */\nexport const CanvasPool = new CanvasPoolClass();\nGlobalResourceRegistry.register(CanvasPool);\n"],
+  "mappings": "oEAKA,IAAMA,EAA0C,CAAA,EAQhC,SAAAC,EAAyBC,EAA2BC,EAAcC,EAClF,CACI,IAAIC,EAAM,WAEV,QAASC,EAAI,EAAGA,EAAIH,EAAMG,IAEfD,GAAAH,EAASI,CAAC,EAAE,IACbD,EAAA,KAAK,KAAKA,EAAK,QAAQ,EACpBA,KAAA,EAGb,OAAOL,EAAaK,CAAG,GAAKE,EAA8BL,EAAUC,EAAME,EAAKD,CAAW,CAC9F,CAEA,SAASG,EAA8BL,EAA2BC,EAAcK,EAAaJ,EAC7F,CACI,IAAMK,EAA0C,CAAA,EAE5CC,EAAY,EAEhB,QAASJ,EAAI,EAAGA,EAAIF,EAAaE,IACjC,CACI,IAAMK,EAAUL,EAAIH,EAAOD,EAASI,CAAC,EAAIM,EAAQ,MAAM,OAEpCH,EAAAC,GAAW,EAAIC,EAAQ,OACvBF,EAAAC,GAAW,EAAIC,EAAQ,KAAA,CAIxC,IAAAE,EAAY,IAAIC,EAAUL,CAAkB,EAElD,OAAAT,EAAaQ,CAAG,EAAIK,EAEbA,CACX,CCtBO,IAAME,EAAN,KACP,CAYI,YAAYC,EACZ,CACS,KAAA,YAAqB,OAAA,OAAO,IAAI,EAChC,KAAA,cAAgBA,GAAiB,CAAA,EACtC,KAAK,iBAAmB,EAAA,CAQpB,wBAAwBC,EAAoBC,EACpD,CACI,IAAMC,EAASC,EAAW,IAAI,EAAE,aAAa,EAE7CD,EAAO,MAAQF,EACfE,EAAO,OAASD,EAEV,IAAAG,EAAUF,EAAO,WAAW,IAAI,EAE/B,MAAA,CAAE,OAAAA,EAAQ,QAAAE,CAAQ,CAAA,CAUtB,2BAA2BC,EAAkBC,EAAmBC,EAAa,EACpF,CACIF,EAAW,KAAK,KAAMA,EAAWE,EAAc,IAAI,EACnDD,EAAY,KAAK,KAAMA,EAAYC,EAAc,IAAI,EACrDF,EAAWG,EAASH,CAAQ,EAC5BC,EAAYE,EAASF,CAAS,EAExB,IAAAG,GAAOJ,GAAY,KAAOC,GAAa,GAExC,KAAK,YAAYG,CAAG,IAEhB,KAAA,YAAYA,CAAG,EAAI,CAAA,GAG5B,IAAIC,EAAmB,KAAK,YAAYD,CAAG,EAAE,IAAI,EAEjD,OAAKC,IAEkBA,EAAA,KAAK,wBAAwBL,EAAUC,CAAS,GAGhEI,CAAA,CAOJ,uBAAuBA,EAC9B,CACI,IAAMR,EAASQ,EAAiB,OAC1B,CAAE,MAAAC,EAAO,OAAAC,CAAA,EAAWV,EAEpBO,GAAOE,GAAS,KAAOC,GAAU,GAEvCF,EAAiB,QAAQ,eAAe,EACxCA,EAAiB,QAAQ,UAAU,EAAG,EAAGC,EAAOC,CAAM,EAEtD,KAAK,YAAYH,CAAG,EAAE,KAAKC,CAAgB,CAAA,CAGxC,OACP,CACI,KAAK,YAAc,CAAA,CAAC,CAE5B,EAOaG,EAAa,IAAIf,EAC9BgB,EAAuB,SAASD,CAAU",
+  "names": ["cachedGroups", "getTextureBatchBindGroup", "textures", "size", "maxTextures", "uid", "i", "generateTextureBatchBindGroup", "key", "bindGroupResources", "bindIndex", "texture", "Texture", "bindGroup", "BindGroup", "CanvasPoolClass", "canvasOptions", "pixelWidth", "pixelHeight", "canvas", "DOMAdapter", "context", "minWidth", "minHeight", "resolution", "nextPow2", "key", "canvasAndContext", "width", "height", "CanvasPool", "GlobalResourceRegistry"]
+}