@safe-engine/pixi 8.1.4 → 8.2.3

package/dist/spine/lib/SpinePipe.js

@@ -0,0 +1,148 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { collectAllRenderables, extensions, ExtensionType, } from 'pixi.js';
+import { BatchableSpineSlot } from './BatchableSpineSlot.js';
+import { MeshAttachment, RegionAttachment } from '@esotericsoftware/spine-core';
+const spineBlendModeMap = {
+    0: 'normal',
+    1: 'add',
+    2: 'multiply',
+    3: 'screen'
+};
+// eslint-disable-next-line max-len
+export class SpinePipe {
+    constructor(renderer) {
+        this.gpuSpineData = {};
+        this._destroyRenderableBound = this.destroyRenderable.bind(this);
+        this.renderer = renderer;
+    }
+    validateRenderable(spine) {
+        spine._validateAndTransformAttachments();
+        // if spine attachments have changed or destroyed, we need to rebuild the batch!
+        if (spine.spineAttachmentsDirty) {
+            return true;
+        }
+        // if the textures have changed, we need to rebuild the batch, but only if the texture is not already in the batch
+        else if (spine.spineTexturesDirty) {
+            // loop through and see if the textures have changed..
+            const drawOrder = spine.skeleton.drawOrder;
+            const gpuSpine = this.gpuSpineData[spine.uid];
+            for (let i = 0, n = drawOrder.length; i < n; i++) {
+                const slot = drawOrder[i];
+                const attachment = slot.getAttachment();
+                if (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment) {
+                    const cacheData = spine._getCachedData(slot, attachment);
+                    const batchableSpineSlot = gpuSpine.slotBatches[cacheData.id];
+                    const texture = cacheData.texture;
+                    if (texture !== batchableSpineSlot.texture) {
+                        if (!batchableSpineSlot._batcher.checkAndUpdateTexture(batchableSpineSlot, texture)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    addRenderable(spine, instructionSet) {
+        var _a, _b;
+        const gpuSpine = this._getSpineData(spine);
+        const batcher = this.renderer.renderPipes.batch;
+        const drawOrder = spine.skeleton.drawOrder;
+        const roundPixels = (this.renderer._roundPixels | spine._roundPixels);
+        spine._validateAndTransformAttachments();
+        spine.spineAttachmentsDirty = false;
+        spine.spineTexturesDirty = false;
+        for (let i = 0, n = drawOrder.length; i < n; i++) {
+            const slot = drawOrder[i];
+            const attachment = slot.getAttachment();
+            const blendMode = spineBlendModeMap[slot.data.blendMode];
+            if (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment) {
+                const cacheData = spine._getCachedData(slot, attachment);
+                const batchableSpineSlot = (_a = gpuSpine.slotBatches)[_b = cacheData.id] || (_a[_b] = new BatchableSpineSlot());
+                batchableSpineSlot.setData(spine, cacheData, blendMode, roundPixels);
+                if (!cacheData.skipRender) {
+                    batcher.addToBatch(batchableSpineSlot, instructionSet);
+                }
+            }
+            const containerAttachment = spine._slotsObject[slot.data.name];
+            if (containerAttachment) {
+                const container = containerAttachment.container;
+                container.includeInBuild = true;
+                collectAllRenderables(container, instructionSet, this.renderer);
+                container.includeInBuild = false;
+            }
+        }
+    }
+    updateRenderable(spine) {
+        var _a;
+        const gpuSpine = this.gpuSpineData[spine.uid];
+        spine._validateAndTransformAttachments();
+        spine.spineAttachmentsDirty = false;
+        spine.spineTexturesDirty = false;
+        const drawOrder = spine.skeleton.drawOrder;
+        for (let i = 0, n = drawOrder.length; i < n; i++) {
+            const slot = drawOrder[i];
+            const attachment = slot.getAttachment();
+            if (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment) {
+                const cacheData = spine._getCachedData(slot, attachment);
+                if (!cacheData.skipRender) {
+                    const batchableSpineSlot = gpuSpine.slotBatches[spine._getCachedData(slot, attachment).id];
+                    (_a = batchableSpineSlot._batcher) === null || _a === void 0 ? void 0 : _a.updateElement(batchableSpineSlot);
+                }
+            }
+        }
+    }
+    destroyRenderable(spine) {
+        this.gpuSpineData[spine.uid] = null;
+        spine.off('destroyed', this._destroyRenderableBound);
+    }
+    destroy() {
+        this.gpuSpineData = null;
+        this.renderer = null;
+    }
+    _getSpineData(spine) {
+        return this.gpuSpineData[spine.uid] || this._initMeshData(spine);
+    }
+    _initMeshData(spine) {
+        this.gpuSpineData[spine.uid] = { slotBatches: {} };
+        spine.on('destroyed', this._destroyRenderableBound);
+        return this.gpuSpineData[spine.uid];
+    }
+}
+/** @ignore */
+SpinePipe.extension = {
+    type: [
+        ExtensionType.WebGLPipes,
+        ExtensionType.WebGPUPipes,
+        ExtensionType.CanvasPipes,
+    ],
+    name: 'spine',
+};
+extensions.add(SpinePipe);

package/dist/spine/lib/SpineTexture.d.ts

@@ -0,0 +1,45 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { Texture as PixiTexture } from 'pixi.js';
+import { BlendMode, Texture, TextureFilter, TextureWrap } from '@esotericsoftware/spine-core';
+import type { BLEND_MODES, TextureSource } from 'pixi.js';
+export declare class SpineTexture extends Texture {
+    private static readonly textureMap;
+    static from(texture: TextureSource): SpineTexture;
+    readonly texture: PixiTexture;
+    private constructor();
+    setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
+    setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
+    dispose(): void;
+    private static toPixiMipMap;
+    private static toPixiTextureFilter;
+    private static toPixiTextureWrap;
+    static toPixiBlending(blend: BlendMode): BLEND_MODES;
+}
+//# sourceMappingURL=SpineTexture.d.ts.map

package/dist/spine/lib/SpineTexture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpineTexture.d.ts","sourceRoot":"","sources":["../../../src/spine/lib/SpineTexture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAE/E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAE9F,OAAO,KAAK,EAAE,WAAW,EAAc,aAAa,EAAa,MAAM,SAAS,CAAC;AAEjF,qBAAa,YAAa,SAAQ,OAAO;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAA4E;WAEhG,IAAI,CAAE,OAAO,EAAE,aAAa,GAAG,YAAY;IAQzD,SAAgB,OAAO,EAAE,WAAW,CAAC;IAErC,OAAO;IAMA,UAAU,CAAE,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,aAAa,GAAG,IAAI;IASrE,QAAQ,CAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI;IAOvD,OAAO,IAAK,IAAI;IAKvB,OAAO,CAAC,MAAM,CAAC,YAAY;IAiB3B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAiBlC,OAAO,CAAC,MAAM,CAAC,iBAAiB;WAgBlB,cAAc,CAAE,KAAK,EAAE,SAAS,GAAG,WAAW;CAkB5D"}

package/dist/spine/lib/SpineTexture.js

@@ -0,0 +1,114 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { Texture as PixiTexture } from 'pixi.js';
+import { BlendMode, Texture, TextureFilter, TextureWrap } from '@esotericsoftware/spine-core';
+export class SpineTexture extends Texture {
+    static from(texture) {
+        if (SpineTexture.textureMap.has(texture)) {
+            return SpineTexture.textureMap.get(texture);
+        }
+        return new SpineTexture(texture);
+    }
+    constructor(image) {
+        // Todo: maybe add error handling if you feed a video texture to spine?
+        super(image.resource);
+        this.texture = PixiTexture.from(image);
+    }
+    setFilters(minFilter, magFilter) {
+        const style = this.texture.source.style;
+        style.minFilter = SpineTexture.toPixiTextureFilter(minFilter);
+        style.magFilter = SpineTexture.toPixiTextureFilter(magFilter);
+        this.texture.source.autoGenerateMipmaps = SpineTexture.toPixiMipMap(minFilter);
+        this.texture.source.updateMipmaps();
+    }
+    setWraps(uWrap, vWrap) {
+        const style = this.texture.source.style;
+        style.addressModeU = SpineTexture.toPixiTextureWrap(uWrap);
+        style.addressModeV = SpineTexture.toPixiTextureWrap(vWrap);
+    }
+    dispose() {
+        // I am not entirely sure about this...
+        this.texture.destroy();
+    }
+    static toPixiMipMap(filter) {
+        switch (filter) {
+            case TextureFilter.Nearest:
+            case TextureFilter.Linear:
+                return false;
+            case TextureFilter.MipMapNearestLinear:
+            case TextureFilter.MipMapNearestNearest:
+            case TextureFilter.MipMapLinearLinear: // TextureFilter.MipMapLinearLinear == TextureFilter.MipMap
+            case TextureFilter.MipMapLinearNearest:
+                return true;
+            default:
+                throw new Error(`Unknown texture filter: ${String(filter)}`);
+        }
+    }
+    static toPixiTextureFilter(filter) {
+        switch (filter) {
+            case TextureFilter.Nearest:
+            case TextureFilter.MipMapNearestLinear:
+            case TextureFilter.MipMapNearestNearest:
+                return 'nearest';
+            case TextureFilter.Linear:
+            case TextureFilter.MipMapLinearLinear: // TextureFilter.MipMapLinearLinear == TextureFilter.MipMap
+            case TextureFilter.MipMapLinearNearest:
+                return 'linear';
+            default:
+                throw new Error(`Unknown texture filter: ${String(filter)}`);
+        }
+    }
+    static toPixiTextureWrap(wrap) {
+        switch (wrap) {
+            case TextureWrap.ClampToEdge:
+                return 'clamp-to-edge';
+            case TextureWrap.MirroredRepeat:
+                return 'mirror-repeat';
+            case TextureWrap.Repeat:
+                return 'repeat';
+            default:
+                throw new Error(`Unknown texture wrap: ${String(wrap)}`);
+        }
+    }
+    static toPixiBlending(blend) {
+        switch (blend) {
+            case BlendMode.Normal:
+                return 'normal';
+            case BlendMode.Additive:
+                return 'add';
+            case BlendMode.Multiply:
+                return 'multiply';
+            case BlendMode.Screen:
+                return 'screen';
+            default:
+                throw new Error(`Unknown blendMode: ${String(blend)}`);
+        }
+    }
+}
+SpineTexture.textureMap = new Map();

package/dist/spine/lib/assets/atlasLoader.d.ts

@@ -0,0 +1,34 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { TextureSource } from 'pixi.js';
+export interface ISpineAtlasMetadata {
+    imageMetadata?: any;
+    images?: TextureSource | string | Record<string, TextureSource | string>;
+}
+//# sourceMappingURL=atlasLoader.d.ts.map

package/dist/spine/lib/assets/atlasLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlasLoader.d.ts","sourceRoot":"","sources":["../../../../src/spine/lib/assets/atlasLoader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAE/E,OAAO,EAQN,aAAa,EACb,MAAM,SAAS,CAAC;AAiHjB,MAAM,WAAW,mBAAmB;IAEnC,aAAa,CAAC,EAAE,GAAG,CAAC;IAGpB,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAAC,CAAC;CACzE"}

package/dist/spine/lib/assets/atlasLoader.js

@@ -0,0 +1,122 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { checkExtension, DOMAdapter, extensions, ExtensionType, LoaderParserPriority, path, Resolver, TextureSource } from 'pixi.js';
+import { SpineTexture } from '../SpineTexture.js';
+import { TextureAtlas } from '@esotericsoftware/spine-core';
+const spineTextureAtlasLoader = {
+    extension: ExtensionType.Asset,
+    resolver: {
+        test: (value) => checkExtension(value, ".atlas"),
+        parse: (value) => {
+            var _a, _b, _c;
+            const split = value.split('.');
+            return {
+                resolution: parseFloat((_c = (_b = (_a = Resolver.RETINA_PREFIX) === null || _a === void 0 ? void 0 : _a.exec(value)) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : '1'),
+                format: split[split.length - 2],
+                src: value,
+            };
+        },
+    },
+    loader: {
+        extension: {
+            type: ExtensionType.LoadParser,
+            priority: LoaderParserPriority.Normal,
+            name: 'spineTextureAtlasLoader',
+        },
+        test(url) {
+            return checkExtension(url, '.atlas');
+        },
+        load(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield DOMAdapter.get().fetch(url);
+                const txt = yield response.text();
+                return txt;
+            });
+        },
+        testParse(asset, options) {
+            const isExtensionRight = checkExtension(options.src, '.atlas');
+            const isString = typeof asset === 'string';
+            return Promise.resolve(isExtensionRight && isString);
+        },
+        unload(atlas) {
+            atlas.dispose();
+        },
+        parse(asset, options, loader) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const metadata = options.data || {};
+                let basePath = path.dirname(options.src);
+                if (basePath && basePath.lastIndexOf('/') !== basePath.length - 1) {
+                    basePath += '/';
+                }
+                // Retval is going to be a texture atlas. However we need to wait for it's callback to resolve this promise.
+                const retval = new TextureAtlas(asset);
+                // If the user gave me only one texture, that one is assumed to be the "first" texture in the atlas
+                if (metadata.images instanceof TextureSource || typeof metadata.images === 'string') {
+                    const pixiTexture = metadata.images;
+                    metadata.images = {};
+                    metadata.images[retval.pages[0].name] = pixiTexture;
+                }
+                // we will wait for all promises for the textures at the same time at the end.
+                const textureLoadingPromises = [];
+                // fill the pages
+                for (const page of retval.pages) {
+                    const pageName = page.name;
+                    const providedPage = (metadata === null || metadata === void 0 ? void 0 : metadata.images) ? metadata.images[pageName] : undefined;
+                    if (providedPage instanceof TextureSource) {
+                        page.setTexture(SpineTexture.from(providedPage));
+                    }
+                    else {
+                        // eslint-disable-next-line max-len
+                        const url = providedPage !== null && providedPage !== void 0 ? providedPage : path.normalize([...basePath.split(path.sep), pageName].join(path.sep));
+                        const assetsToLoadIn = {
+                            src: url,
+                            data: Object.assign(Object.assign({}, metadata.imageMetadata), { alphaMode: page.pma ? 'premultiplied-alpha' : 'premultiply-alpha-on-upload' })
+                        };
+                        const pixiPromise = loader.load(assetsToLoadIn).then((texture) => {
+                            page.setTexture(SpineTexture.from(texture.source));
+                        });
+                        textureLoadingPromises.push(pixiPromise);
+                    }
+                }
+                yield Promise.all(textureLoadingPromises);
+                return retval;
+            });
+        },
+    },
+};
+extensions.add(spineTextureAtlasLoader);

package/dist/spine/lib/assets/skeletonLoader.d.ts

@@ -0,0 +1,30 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+export {};
+//# sourceMappingURL=skeletonLoader.d.ts.map

package/dist/spine/lib/assets/skeletonLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeletonLoader.d.ts","sourceRoot":"","sources":["../../../../src/spine/lib/assets/skeletonLoader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E"}

package/dist/spine/lib/assets/skeletonLoader.js

@@ -0,0 +1,70 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { checkExtension, DOMAdapter, extensions, ExtensionType, LoaderParserPriority } from 'pixi.js';
+function isJson(resource) {
+    return Object.prototype.hasOwnProperty.call(resource, 'bones');
+}
+function isBuffer(resource) {
+    return resource instanceof Uint8Array;
+}
+const spineLoaderExtension = {
+    extension: ExtensionType.Asset,
+    loader: {
+        extension: {
+            type: ExtensionType.LoadParser,
+            priority: LoaderParserPriority.Normal,
+            name: 'spineSkeletonLoader',
+        },
+        test(url) {
+            return checkExtension(url, '.skel');
+        },
+        load(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield DOMAdapter.get().fetch(url);
+                const buffer = new Uint8Array(yield response.arrayBuffer());
+                return buffer;
+            });
+        },
+        testParse(asset, options) {
+            const isJsonSpineModel = checkExtension(options.src, '.json') && isJson(asset);
+            const isBinarySpineModel = checkExtension(options.src, '.skel') && isBuffer(asset);
+            return Promise.resolve(isJsonSpineModel || isBinarySpineModel);
+        },
+    },
+};
+extensions.add(spineLoaderExtension);

package/dist/spine/lib/darktint/DarkTintBatchGeometry.d.ts

@@ -0,0 +1,33 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { Geometry } from 'pixi.js';
+export declare class DarkTintBatchGeometry extends Geometry {
+    constructor();
+}
+//# sourceMappingURL=DarkTintBatchGeometry.d.ts.map

package/dist/spine/lib/darktint/DarkTintBatchGeometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DarkTintBatchGeometry.d.ts","sourceRoot":"","sources":["../../../../src/spine/lib/darktint/DarkTintBatchGeometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAE/E,OAAO,EAAuB,QAAQ,EAAE,MAAM,SAAS,CAAC;AAKxD,qBAAa,qBAAsB,SAAQ,QAAQ;;CAwDlD"}