@safe-engine/pixi 8.7.4 → 8.8.2

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/RenderTargetSystem.js

@@ -0,0 +1,306 @@
+import { Matrix } from '../../../../maths/matrix/Matrix';
+import { Rectangle } from '../../../../maths/shapes/Rectangle';
+import { CLEAR } from '../../gl/const';
+import { calculateProjection } from '../../gpu/renderTarget/calculateProjection';
+import { SystemRunner } from '../system/SystemRunner';
+import { CanvasSource } from '../texture/sources/CanvasSource';
+import { TextureSource } from '../texture/sources/TextureSource';
+import { Texture } from '../texture/Texture';
+import { getCanvasTexture } from '../texture/utils/getCanvasTexture';
+import { isRenderingToScreen } from './isRenderingToScreen';
+import { RenderTarget } from './RenderTarget';
+/**
+ * A system that manages render targets. A render target is essentially a place where the shaders can color in the pixels.
+ * The render target system is responsible for binding the render target to the renderer, and managing the viewport.
+ * Render targets can be pushed and popped.
+ *
+ * To make it easier, you can also bind textures and canvases too. This will automatically create a render target for you.
+ * The render target itself is a lot more powerful than just a texture or canvas,
+ * as it can have multiple textures attached to it.
+ * It will also give ou fine grain control over the stencil buffer / depth texture.
+ * @example
+ *
+ * ```js
+ *
+ * // create a render target
+ * const renderTarget = new RenderTarget({
+ *   colorTextures: [new TextureSource({ width: 100, height: 100 })],
+ * });
+ *
+ * // bind the render target
+ * renderer.renderTarget.bind(renderTarget);
+ *
+ * // draw something!
+ * ```
+ * @category rendering
+ * @advanced
+ */
+export class RenderTargetSystem {
+    constructor(renderer) {
+        /** This is the root viewport for the render pass*/
+        this.rootViewPort = new Rectangle();
+        /** the current viewport that the gpu is using */
+        this.viewport = new Rectangle();
+        /**
+         * a runner that lets systems know if the active render target has changed.
+         * Eg the Stencil System needs to know so it can manage the stencil buffer
+         */
+        this.onRenderTargetChange = new SystemRunner('onRenderTargetChange');
+        /** the projection matrix that is used by the shaders based on the active render target and the viewport */
+        this.projectionMatrix = new Matrix();
+        /** the default clear color for render targets */
+        this.defaultClearColor = [0, 0, 0, 0];
+        /**
+         * a hash that stores the render target for a given render surface. When you pass in a texture source,
+         * a render target is created for it. This map stores and makes it easy to retrieve the render target
+         */
+        this._renderSurfaceToRenderTargetHash = new Map();
+        /** A hash that stores a gpu render target for a given render target. */
+        this._gpuRenderTargetHash = Object.create(null);
+        /**
+         * A stack that stores the render target and frame that is currently being rendered to.
+         * When push is called, the current render target is stored in this stack.
+         * When pop is called, the previous render target is restored.
+         */
+        this._renderTargetStack = [];
+        this._renderer = renderer;
+        renderer.renderableGC.addManagedHash(this, '_gpuRenderTargetHash');
+    }
+    /** called when dev wants to finish a render pass */
+    finishRenderPass() {
+        this.adaptor.finishRenderPass(this.renderTarget);
+    }
+    /**
+     * called when the renderer starts to render a scene.
+     * @param options
+     * @param options.target - the render target to render to
+     * @param options.clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+     * @param options.clearColor - the color to clear to
+     * @param options.frame - the frame to render to
+     */
+    renderStart({ target, clear, clearColor, frame }) {
+        var _a, _b;
+        // TODO no need to reset this - use optimised index instead
+        this._renderTargetStack.length = 0;
+        this.push(target, clear, clearColor, frame);
+        this.rootViewPort.copyFrom(this.viewport);
+        this.rootRenderTarget = this.renderTarget;
+        this.renderingToScreen = isRenderingToScreen(this.rootRenderTarget);
+        (_b = (_a = this.adaptor).prerender) === null || _b === void 0 ? void 0 : _b.call(_a, this.rootRenderTarget);
+    }
+    postrender() {
+        var _a, _b;
+        (_b = (_a = this.adaptor).postrender) === null || _b === void 0 ? void 0 : _b.call(_a, this.rootRenderTarget);
+    }
+    /**
+     * Binding a render surface! This is the main function of the render target system.
+     * It will take the RenderSurface (which can be a texture, canvas, or render target) and bind it to the renderer.
+     * Once bound all draw calls will be rendered to the render surface.
+     *
+     * If a frame is not provide and the render surface is a texture, the frame of the texture will be used.
+     * @param renderSurface - the render surface to bind
+     * @param clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+     * @param clearColor - the color to clear to
+     * @param frame - the frame to render to
+     * @returns the render target that was bound
+     */
+    bind(renderSurface, clear = true, clearColor, frame) {
+        const renderTarget = this.getRenderTarget(renderSurface);
+        const didChange = this.renderTarget !== renderTarget;
+        this.renderTarget = renderTarget;
+        this.renderSurface = renderSurface;
+        const gpuRenderTarget = this.getGpuRenderTarget(renderTarget);
+        if (renderTarget.pixelWidth !== gpuRenderTarget.width
+            || renderTarget.pixelHeight !== gpuRenderTarget.height) {
+            this.adaptor.resizeGpuRenderTarget(renderTarget);
+            gpuRenderTarget.width = renderTarget.pixelWidth;
+            gpuRenderTarget.height = renderTarget.pixelHeight;
+        }
+        const source = renderTarget.colorTexture;
+        const viewport = this.viewport;
+        const pixelWidth = source.pixelWidth;
+        const pixelHeight = source.pixelHeight;
+        if (!frame && renderSurface instanceof Texture) {
+            frame = renderSurface.frame;
+        }
+        if (frame) {
+            const resolution = source._resolution;
+            viewport.x = ((frame.x * resolution) + 0.5) | 0;
+            viewport.y = ((frame.y * resolution) + 0.5) | 0;
+            viewport.width = ((frame.width * resolution) + 0.5) | 0;
+            viewport.height = ((frame.height * resolution) + 0.5) | 0;
+        }
+        else {
+            viewport.x = 0;
+            viewport.y = 0;
+            viewport.width = pixelWidth;
+            viewport.height = pixelHeight;
+        }
+        calculateProjection(this.projectionMatrix, 0, 0, viewport.width / source.resolution, viewport.height / source.resolution, !renderTarget.isRoot);
+        this.adaptor.startRenderPass(renderTarget, clear, clearColor, viewport);
+        if (didChange) {
+            this.onRenderTargetChange.emit(renderTarget);
+        }
+        return renderTarget;
+    }
+    clear(target, clear = CLEAR.ALL, clearColor) {
+        if (!clear)
+            return;
+        if (target) {
+            target = this.getRenderTarget(target);
+        }
+        this.adaptor.clear(target || this.renderTarget, clear, clearColor, this.viewport);
+    }
+    contextChange() {
+        this._gpuRenderTargetHash = Object.create(null);
+    }
+    /**
+     * Push a render surface to the renderer. This will bind the render surface to the renderer,
+     * @param renderSurface - the render surface to push
+     * @param clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+     * @param clearColor - the color to clear to
+     * @param frame - the frame to use when rendering to the render surface
+     */
+    push(renderSurface, clear = CLEAR.ALL, clearColor, frame) {
+        const renderTarget = this.bind(renderSurface, clear, clearColor, frame);
+        this._renderTargetStack.push({
+            renderTarget,
+            frame,
+        });
+        return renderTarget;
+    }
+    /** Pops the current render target from the renderer and restores the previous render target. */
+    pop() {
+        this._renderTargetStack.pop();
+        const currentRenderTargetData = this._renderTargetStack[this._renderTargetStack.length - 1];
+        this.bind(currentRenderTargetData.renderTarget, false, null, currentRenderTargetData.frame);
+    }
+    /**
+     * Gets the render target from the provide render surface. Eg if its a texture,
+     * it will return the render target for the texture.
+     * If its a render target, it will return the same render target.
+     * @param renderSurface - the render surface to get the render target for
+     * @returns the render target for the render surface
+     */
+    getRenderTarget(renderSurface) {
+        var _a;
+        if ((renderSurface.isTexture)) {
+            renderSurface = renderSurface.source;
+        }
+        return (_a = this._renderSurfaceToRenderTargetHash.get(renderSurface)) !== null && _a !== void 0 ? _a : this._initRenderTarget(renderSurface);
+    }
+    /**
+     * Copies a render surface to another texture.
+     *
+     * NOTE:
+     * for sourceRenderSurfaceTexture, The render target must be something that is written too by the renderer
+     *
+     * The following is not valid:
+     * @example
+     * const canvas = document.createElement('canvas')
+     * canvas.width = 200;
+     * canvas.height = 200;
+     *
+     * const ctx = canvas2.getContext('2d')!
+     * ctx.fillStyle = 'red'
+     * ctx.fillRect(0, 0, 200, 200);
+     *
+     * const texture = RenderTexture.create({
+     *   width: 200,
+     *   height: 200,
+     * })
+     * const renderTarget = renderer.renderTarget.getRenderTarget(canvas2);
+     *
+     * renderer.renderTarget.copyToTexture(renderTarget,texture, {x:0,y:0},{width:200,height:200},{x:0,y:0});
+     *
+     * The best way to copy a canvas is to create a texture from it. Then render with that.
+     *
+     * Parsing in a RenderTarget canvas context (with a 2d context)
+     * @param sourceRenderSurfaceTexture - the render surface to copy from
+     * @param destinationTexture - the texture to copy to
+     * @param originSrc - the origin of the copy
+     * @param originSrc.x - the x origin of the copy
+     * @param originSrc.y - the y origin of the copy
+     * @param size - the size of the copy
+     * @param size.width - the width of the copy
+     * @param size.height - the height of the copy
+     * @param originDest - the destination origin (top left to paste from!)
+     * @param originDest.x - the x origin of the paste
+     * @param originDest.y - the y origin of the paste
+     */
+    copyToTexture(sourceRenderSurfaceTexture, destinationTexture, originSrc, size, originDest) {
+        // fit the size to the source we don't want to go out of bounds
+        if (originSrc.x < 0) {
+            size.width += originSrc.x;
+            originDest.x -= originSrc.x;
+            originSrc.x = 0;
+        }
+        if (originSrc.y < 0) {
+            size.height += originSrc.y;
+            originDest.y -= originSrc.y;
+            originSrc.y = 0;
+        }
+        const { pixelWidth, pixelHeight } = sourceRenderSurfaceTexture;
+        size.width = Math.min(size.width, pixelWidth - originSrc.x);
+        size.height = Math.min(size.height, pixelHeight - originSrc.y);
+        return this.adaptor.copyToTexture(sourceRenderSurfaceTexture, destinationTexture, originSrc, size, originDest);
+    }
+    /**
+     * ensures that we have a depth stencil buffer available to render to
+     * This is used by the mask system to make sure we have a stencil buffer.
+     */
+    ensureDepthStencil() {
+        if (!this.renderTarget.stencil) {
+            this.renderTarget.stencil = true;
+            this.adaptor.startRenderPass(this.renderTarget, false, null, this.viewport);
+        }
+    }
+    /** nukes the render target system */
+    destroy() {
+        this._renderer = null;
+        this._renderSurfaceToRenderTargetHash.forEach((renderTarget, key) => {
+            if (renderTarget !== key) {
+                renderTarget.destroy();
+            }
+        });
+        this._renderSurfaceToRenderTargetHash.clear();
+        this._gpuRenderTargetHash = Object.create(null);
+    }
+    _initRenderTarget(renderSurface) {
+        let renderTarget = null;
+        if (CanvasSource.test(renderSurface)) {
+            renderSurface = getCanvasTexture(renderSurface).source;
+        }
+        if (renderSurface instanceof RenderTarget) {
+            renderTarget = renderSurface;
+        }
+        else if (renderSurface instanceof TextureSource) {
+            renderTarget = new RenderTarget({
+                colorTextures: [renderSurface],
+            });
+            if (renderSurface.source instanceof CanvasSource) {
+                renderTarget.isRoot = true;
+            }
+            // TODO add a test for this
+            renderSurface.once('destroy', () => {
+                renderTarget.destroy();
+                this._renderSurfaceToRenderTargetHash.delete(renderSurface);
+                const gpuRenderTarget = this._gpuRenderTargetHash[renderTarget.uid];
+                if (gpuRenderTarget) {
+                    this._gpuRenderTargetHash[renderTarget.uid] = null;
+                    this.adaptor.destroyGpuRenderTarget(gpuRenderTarget);
+                }
+            });
+        }
+        this._renderSurfaceToRenderTargetHash.set(renderSurface, renderTarget);
+        return renderTarget;
+    }
+    getGpuRenderTarget(renderTarget) {
+        return this._gpuRenderTargetHash[renderTarget.uid]
+            || (this._gpuRenderTargetHash[renderTarget.uid] = this.adaptor.initGpuRenderTarget(renderTarget));
+    }
+    resetState() {
+        this.renderTarget = null;
+        this.renderSurface = null;
+    }
+}

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/isRenderingToScreen.d.ts

@@ -0,0 +1,10 @@
+import type { RenderTarget } from './RenderTarget';
+/**
+ * Checks if the render target is viewable on the screen
+ * Basically, is it a canvas element and is that canvas element in the DOM
+ * @param renderTarget - the render target to check
+ * @returns true if the render target is viewable on the screen
+ * @internal
+ */
+export declare function isRenderingToScreen(renderTarget: RenderTarget): boolean;
+//# sourceMappingURL=isRenderingToScreen.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/isRenderingToScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isRenderingToScreen.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/renderers/shared/renderTarget/isRenderingToScreen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAKvE"}

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/isRenderingToScreen.js

@@ -0,0 +1,11 @@
+/**
+ * Checks if the render target is viewable on the screen
+ * Basically, is it a canvas element and is that canvas element in the DOM
+ * @param renderTarget - the render target to check
+ * @returns true if the render target is viewable on the screen
+ * @internal
+ */
+export function isRenderingToScreen(renderTarget) {
+    const resource = renderTarget.colorTexture.source.resource;
+    return ((globalThis.HTMLCanvasElement && resource instanceof HTMLCanvasElement) && document.body.contains(resource));
+}

package/dist/packages/pixijs/src/rendering/renderers/shared/shader/Shader.d.ts

@@ -0,0 +1,234 @@
+import EventEmitter from 'eventemitter3';
+import { GlProgram } from '../../gl/shader/GlProgram';
+import { BindGroup } from '../../gpu/shader/BindGroup';
+import { GpuProgram } from '../../gpu/shader/GpuProgram';
+import type { GlProgramOptions } from '../../gl/shader/GlProgram';
+import type { GpuProgramOptions } from '../../gpu/shader/GpuProgram';
+/**
+ * A record of {@link BindGroup}'s used by the shader.
+ *
+ * `Record<number, BindGroup>`
+ * @category rendering
+ * @advanced
+ */
+export type ShaderGroups = Record<number, BindGroup>;
+interface ShaderBase {
+    /** The WebGL program used by the WebGL renderer. */
+    glProgram?: GlProgram;
+    /** The WebGPU program used by the WebGPU renderer. */
+    gpuProgram?: GpuProgram;
+    /**
+     * A number that uses two bits on whether the shader is compatible with the WebGL renderer and/or the WebGPU renderer.
+     * 0b00 - not compatible with either
+     * 0b01 - compatible with WebGL
+     * 0b10 - compatible with WebGPU
+     * This is automatically set based on if a {@link GlProgram} or {@link GpuProgram} is provided.
+     */
+    compatibleRenderers?: number;
+}
+/**
+ * A base interface for shaders that includes the common properties.
+ * @category rendering
+ * @advanced
+ */
+export interface GlShaderWith extends ShaderBase {
+    /** The WebGL program used by the WebGL renderer. */
+    glProgram: GlProgram;
+}
+/**
+ * A base interface for shaders that includes the common properties.
+ * @category rendering
+ * @advanced
+ */
+export interface GpuShaderWith extends ShaderBase {
+    /** The WebGPU program used by the WebGPU renderer. */
+    gpuProgram: GpuProgram;
+}
+/**
+ * A descriptor for a shader with groups.
+ * This is used to define a shader that uses {@link BindGroup}'s.
+ * @category rendering
+ * @advanced
+ */
+export interface ShaderWithGroupsDescriptor {
+    /** A record of {@link BindGroup}'s used by the shader. */
+    groups: ShaderGroups;
+    /** an optional map of how to bind the groups. This is automatically generated by reading the WebGPU program */
+    groupMap?: Record<string, Record<string, any>>;
+}
+interface ShaderWithResourcesDescriptor {
+    /**
+     * A key value of uniform resources used by the shader.
+     * Under the hood pixi will look at the provided shaders and figure out where
+     * the resources are mapped. Its up to you to make sure the resource key
+     * matches the uniform name in the webGPU program. WebGL is a little more forgiving!
+     */
+    resources?: Record<string, any>;
+}
+/**
+ * A descriptor for a shader
+ * @category rendering
+ * @advanced
+ */
+export type ShaderWith = GlShaderWith | GpuShaderWith;
+/**
+ * A descriptor for a shader with groups.
+ * @category rendering
+ * @advanced
+ */
+export type ShaderWithGroups = ShaderWithGroupsDescriptor & ShaderWith;
+/**
+ * A descriptor for a shader with resources. This is an easier way to work with uniforms.
+ * especially when you are not working with bind groups
+ * @category rendering
+ * @advanced
+ */
+export type ShaderWithResources = ShaderWithResourcesDescriptor & ShaderWith;
+/**
+ * A shader that can be used with both WebGL and WebGPU.
+ * @category rendering
+ * @advanced
+ */
+export interface IShaderWithResources extends ShaderWithResourcesDescriptor, ShaderBase {
+}
+/**
+ * A descriptor for a shader that can be used with both WebGL and WebGPU.
+ * @category rendering
+ * @advanced
+ */
+export type ShaderDescriptor = ShaderWithGroups & ShaderWithResources;
+/**
+ * A descriptor for a shader with resources and groups.
+ * @category rendering
+ */
+type GlShaderFromWith = {
+    gpu?: GpuProgramOptions;
+    gl: GlProgramOptions;
+};
+/**
+ * A descriptor for a shader with groups and resources.
+ * @category rendering
+ */
+type GpuShaderFromWith = {
+    gpu: GpuProgramOptions;
+    gl?: GlProgramOptions;
+};
+/**
+ * A descriptor for a shader that can be used with both WebGL and WebGPU.
+ * @category rendering
+ * @advanced
+ */
+export type ShaderFromGroups = (GlShaderFromWith | GpuShaderFromWith) & Omit<ShaderWithGroups, 'glProgram' | 'gpuProgram'>;
+/**
+ * A descriptor for a shader that can be used with both WebGL and WebGPU.
+ * @category rendering
+ * @advanced
+ */
+export type ShaderFromResources = (GlShaderFromWith | GpuShaderFromWith) & Omit<ShaderWithResources, 'glProgram' | 'gpuProgram'>;
+/**
+ * The Shader class is an integral part of the PixiJS graphics pipeline.
+ * Central to rendering in PixiJS are two key elements: A [shader] and a [geometry].
+ * The shader incorporates a {@link GlProgram} for WebGL or a {@link GpuProgram} for WebGPU,
+ * instructing the respective technology on how to render the geometry.
+ *
+ * The primary goal of the Shader class is to offer a unified interface compatible with both WebGL and WebGPU.
+ * When constructing a shader, you need to provide both a WebGL program and a WebGPU program due to the distinctions
+ * between the two rendering engines. If only one is provided, the shader won't function with the omitted renderer.
+ *
+ * Both WebGL and WebGPU utilize the same resource object when passed into the shader.
+ * Post-creation, the shader's interface remains consistent across both WebGL and WebGPU.
+ * The sole distinction lies in whether a glProgram or a gpuProgram is employed.
+ *
+ * Modifying shader uniforms, which can encompass:
+ *  - TextureSampler {@link TextureStyle}
+ *  - TextureSource {@link TextureSource}
+ *  - UniformsGroups {@link UniformGroup}
+ * @example
+ *
+ * const shader = new Shader({
+ *     glProgram: glProgram,
+ *     gpuProgram: gpuProgram,
+ *     resources: {
+ *         uTexture: texture.source,
+ *         uSampler: texture.sampler,
+ *         uColor: [1, 0, 0, 1],
+ *     },
+ * });
+ *
+ * // update the uniforms
+ * shader.resources.uColor[1] = 1;
+ * shader.resources.uTexture = texture2.source;
+ * @class
+ * @category rendering
+ * @advanced
+ */
+export declare class Shader extends EventEmitter<{
+    'destroy': Shader;
+}> {
+    /** A unique identifier for the shader */
+    readonly uid: number;
+    /** An instance of the GPU program used by the WebGPU renderer */
+    gpuProgram: GpuProgram;
+    /** An instance of the GL program used by the WebGL renderer */
+    glProgram: GlProgram;
+    /**
+     * A number that uses two bits on whether the shader is compatible with the WebGL renderer and/or the WebGPU renderer.
+     * 0b00 - not compatible with either
+     * 0b01 - compatible with WebGL
+     * 0b10 - compatible with WebGPU
+     * This is automatically set based on if a {@link GlProgram} or {@link GpuProgram} is provided.
+     */
+    readonly compatibleRenderers: number;
+    /** */
+    groups: Record<number, BindGroup>;
+    /** A record of the resources used by the shader. */
+    resources: Record<string, any>;
+    /**
+     * A record of the uniform groups and resources used by the shader.
+     * This is used by WebGL renderer to sync uniform data.
+     * @internal
+     */
+    _uniformBindMap: Record<number, Record<number, string>>;
+    private readonly _ownedBindGroups;
+    /**
+     * Fired after rendering finishes.
+     * @event Shader#destroy
+     */
+    /**
+     * There are two ways to create a shader.
+     * one is to pass in resources which is a record of uniform groups and resources.
+     * another is to pass in groups which is a record of {@link BindGroup}s.
+     * this second method is really to make use of shared {@link BindGroup}s.
+     * For most cases you will want to use resources as they are easier to work with.
+     * USe Groups if you want to share {@link BindGroup}s between shaders.
+     * you cannot mix and match - either use resources or groups.
+     * @param options - The options for the shader
+     */
+    constructor(options: ShaderWithResources);
+    constructor(options: ShaderWithGroups);
+    /**
+     * Sometimes a resource group will be provided later (for example global uniforms)
+     * In such cases, this method can be used to let the shader know about the group.
+     * @param name - the name of the resource group
+     * @param groupIndex - the index of the group (should match the webGPU shader group location)
+     * @param bindIndex - the index of the bind point (should match the webGPU shader bind point)
+     */
+    addResource(name: string, groupIndex: number, bindIndex: number): void;
+    private _buildResourceAccessor;
+    /**
+     * Use to destroy the shader when its not longer needed.
+     * It will destroy the resources and remove listeners.
+     * @param destroyPrograms - if the programs should be destroyed as well.
+     * Make sure its not being used by other shaders!
+     */
+    destroy(destroyPrograms?: boolean): void;
+    /**
+     * A short hand function to create a shader based of a vertex and fragment shader.
+     * @param options
+     * @returns A shiny new PixiJS shader!
+     */
+    static from(options: ShaderFromGroups): Shader;
+    static from(options: ShaderFromResources): Shader;
+}
+export {};
+//# sourceMappingURL=Shader.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/shader/Shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Shader.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/renderers/shared/shader/Shader.ts"],"names":[],"mappings":"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"}