sdfsdfs

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'color'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'color'
+ * @memberof filters
+ */
+export declare class ColorBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+var GLhls = require('../filters/blend-modes/hls/GLhls.js');
+var GPUhls = require('../filters/blend-modes/hls/GPUhls.js');
+
+"use strict";
+class ColorBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                ${GLhls.hslgl}
+
+                vec3 blendColor(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                ${GPUhls.hslgpu}
+
+                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorBlend.extension = {
+  name: "color",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.ColorBlend = ColorBlend;
+//# sourceMappingURL=ColorBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorBlend.js","sources":["../../src/advanced-blend-modes/ColorBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\nimport { hslgl } from '../filters/blend-modes/hls/GLhls';\nimport { hslgpu } from '../filters/blend-modes/hls/GPUhls';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'color'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color'\n * @memberof filters\n */\nexport class ColorBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                ${hslgl}\n\n                vec3 blendColor(vec3 base, vec3 blend,  float opacity)\n                {\n                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                ${hslgpu}\n\n                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","hslgl","hslgpu","ExtensionType"],"mappings":";;;;;;;;AAiBO,MAAM,mBAAmBA,+BAChC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA,gBAAA,EACTC,WAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAOP,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA,gBAAA,EACTC,aAAM,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAOR,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAvCa,UAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,OAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.mjs

@@ -0,0 +1,46 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+import { hslgl } from '../filters/blend-modes/hls/GLhls.mjs';
+import { hslgpu } from '../filters/blend-modes/hls/GPUhls.mjs';
+
+"use strict";
+class ColorBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                ${hslgl}
+
+                vec3 blendColor(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                ${hslgpu}
+
+                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorBlend.extension = {
+  name: "color",
+  type: ExtensionType.BlendMode
+};
+
+export { ColorBlend };
+//# sourceMappingURL=ColorBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorBlend.mjs","sources":["../../src/advanced-blend-modes/ColorBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\nimport { hslgl } from '../filters/blend-modes/hls/GLhls';\nimport { hslgpu } from '../filters/blend-modes/hls/GPUhls';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'color'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color'\n * @memberof filters\n */\nexport class ColorBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                ${hslgl}\n\n                vec3 blendColor(vec3 base, vec3 blend,  float opacity)\n                {\n                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendColor(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                ${hslgpu}\n\n                fn blendColorOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (setLuminosity(blend, getLuminosity(base)) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendColorOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;;;AAiBO,MAAM,mBAAmB,eAChC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA,gBAAA,EACT,KAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAOP,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA,gBAAA,EACT,MAAM,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAOR,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAvCa,UAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,OAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.d.ts

@@ -0,0 +1,20 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Looks at the color information in each channel and darkens the base color to
+ * reflect the blend color by increasing the contrast between the two.
+ *
+ * Available as `container.blendMode = 'color-burn'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'color-burn'
+ * @memberof filters
+ */
+export declare class ColorBurnBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class ColorBurnBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float colorBurn(float base, float blend)
+                {
+                    return max((1.0 - ((1.0 - base) / blend)), 0.0);
+                }
+
+                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn colorBurn(base:f32, blend:f32) -> f32
+                {
+                    return max((1.0-((1.0-base)/blend)),0.0);
+                }
+
+                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorBurnBlend.extension = {
+  name: "color-burn",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.ColorBurnBlend = ColorBurnBlend;
+//# sourceMappingURL=ColorBurnBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorBurnBlend.js","sources":["../../src/advanced-blend-modes/ColorBurnBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and darkens the base color to\n * reflect the blend color by increasing the contrast between the two.\n *\n * Available as `container.blendMode = 'color-burn'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color-burn'\n * @memberof filters\n */\nexport class ColorBurnBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color-burn',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float colorBurn(float base, float blend)\n                {\n                    return max((1.0 - ((1.0 - base) / blend)), 0.0);\n                }\n\n                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        colorBurn(base.r, blend.r),\n                        colorBurn(base.g, blend.g),\n                        colorBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn colorBurn(base:f32, blend:f32) -> f32\n                {\n                    return max((1.0-((1.0-base)/blend)),0.0);\n                }\n\n                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        colorBurn(base.r, blend.r),\n                        colorBurn(base.g, blend.g),\n                        colorBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAoBO,MAAM,uBAAuBA,+BACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class ColorBurnBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float colorBurn(float base, float blend)
+                {
+                    return max((1.0 - ((1.0 - base) / blend)), 0.0);
+                }
+
+                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn colorBurn(base:f32, blend:f32) -> f32
+                {
+                    return max((1.0-((1.0-base)/blend)),0.0);
+                }
+
+                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorBurn(base.r, blend.r),
+                        colorBurn(base.g, blend.g),
+                        colorBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorBurnBlend.extension = {
+  name: "color-burn",
+  type: ExtensionType.BlendMode
+};
+
+export { ColorBurnBlend };
+//# sourceMappingURL=ColorBurnBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorBurnBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorBurnBlend.mjs","sources":["../../src/advanced-blend-modes/ColorBurnBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and darkens the base color to\n * reflect the blend color by increasing the contrast between the two.\n *\n * Available as `container.blendMode = 'color-burn'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color-burn'\n * @memberof filters\n */\nexport class ColorBurnBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color-burn',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float colorBurn(float base, float blend)\n                {\n                    return max((1.0 - ((1.0 - base) / blend)), 0.0);\n                }\n\n                vec3 blendColorBurn(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        colorBurn(base.r, blend.r),\n                        colorBurn(base.g, blend.g),\n                        colorBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendColorBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn colorBurn(base:f32, blend:f32) -> f32\n                {\n                    return max((1.0-((1.0-base)/blend)),0.0);\n                }\n\n                fn blendColorBurn(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        colorBurn(base.r, blend.r),\n                        colorBurn(base.g, blend.g),\n                        colorBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendColorBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAoBO,MAAM,uBAAuB,eACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.
+ * Available as `container.blendMode = 'color-dodge'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'color-dodge'
+ * @memberof filters
+ */
+export declare class ColorDodgeBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class ColorDodgeBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float colorDodge(float base, float blend)
+                {
+                    return base / (1.0 - blend);
+                }
+
+                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn colorDodge(base: f32, blend: f32) -> f32
+                {
+                    return base / (1.0 - blend);
+                }
+
+                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorDodgeBlend.extension = {
+  name: "color-dodge",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.ColorDodgeBlend = ColorDodgeBlend;
+//# sourceMappingURL=ColorDodgeBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorDodgeBlend.js","sources":["../../src/advanced-blend-modes/ColorDodgeBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.\n * Available as `container.blendMode = 'color-dodge'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color-dodge'\n * @memberof filters\n */\nexport class ColorDodgeBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color-dodge',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float colorDodge(float base, float blend)\n                {\n                    return base / (1.0 - blend);\n                }\n\n                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        colorDodge(base.r, blend.r),\n                        colorDodge(base.g, blend.g),\n                        colorDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn colorDodge(base: f32, blend: f32) -> f32\n                {\n                    return base / (1.0 - blend);\n                }\n\n                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        colorDodge(base.r, blend.r),\n                        colorDodge(base.g, blend.g),\n                        colorDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `,\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAkBO,MAAM,wBAAwBA,+BACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,aAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class ColorDodgeBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float colorDodge(float base, float blend)
+                {
+                    return base / (1.0 - blend);
+                }
+
+                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn colorDodge(base: f32, blend: f32) -> f32
+                {
+                    return base / (1.0 - blend);
+                }
+
+                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        colorDodge(base.r, blend.r),
+                        colorDodge(base.g, blend.g),
+                        colorDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+ColorDodgeBlend.extension = {
+  name: "color-dodge",
+  type: ExtensionType.BlendMode
+};
+
+export { ColorDodgeBlend };
+//# sourceMappingURL=ColorDodgeBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/ColorDodgeBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorDodgeBlend.mjs","sources":["../../src/advanced-blend-modes/ColorDodgeBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.\n * Available as `container.blendMode = 'color-dodge'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'color-dodge'\n * @memberof filters\n */\nexport class ColorDodgeBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'color-dodge',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float colorDodge(float base, float blend)\n                {\n                    return base / (1.0 - blend);\n                }\n\n                vec3 blendColorDodge(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        colorDodge(base.r, blend.r),\n                        colorDodge(base.g, blend.g),\n                        colorDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendColorDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn colorDodge(base: f32, blend: f32) -> f32\n                {\n                    return base / (1.0 - blend);\n                }\n\n                fn blendColorDodge(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        colorDodge(base.r, blend.r),\n                        colorDodge(base.g, blend.g),\n                        colorDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                    out = vec4<f32>(blendColorDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `,\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAkBO,MAAM,wBAAwB,eACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,aAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Uses each color channel to select the darker of the following two values; base or blend color
+ * Available as `container.blendMode = 'darken'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'darken'
+ * @memberof filters
+ */
+export declare class DarkenBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class DarkenBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendDarken(vec3 base, vec3 blend, float opacity)
+                {
+                    return (min(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (min(blend,base) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+DarkenBlend.extension = {
+  name: "darken",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.DarkenBlend = DarkenBlend;
+//# sourceMappingURL=DarkenBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DarkenBlend.js","sources":["../../src/advanced-blend-modes/DarkenBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Uses each color channel to select the darker of the following two values; base or blend color\n * Available as `container.blendMode = 'darken'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'darken'\n * @memberof filters\n */\nexport class DarkenBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'darken',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendDarken(vec3 base, vec3 blend, float opacity)\n                {\n                    return (min(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (min(blend,base) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAgBO,MAAM,oBAAoBA,+BACjC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,WAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,QAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.mjs

@@ -0,0 +1,40 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class DarkenBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendDarken(vec3 base, vec3 blend, float opacity)
+                {
+                    return (min(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (min(blend,base) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+DarkenBlend.extension = {
+  name: "darken",
+  type: ExtensionType.BlendMode
+};
+
+export { DarkenBlend };
+//# sourceMappingURL=DarkenBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/DarkenBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DarkenBlend.mjs","sources":["../../src/advanced-blend-modes/DarkenBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Uses each color channel to select the darker of the following two values; base or blend color\n * Available as `container.blendMode = 'darken'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'darken'\n * @memberof filters\n */\nexport class DarkenBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'darken',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendDarken(vec3 base, vec3 blend, float opacity)\n                {\n                    return (min(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendDarken(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn blendDarken(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (min(blend,base) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendDarken(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAgBO,MAAM,oBAAoB,eACjC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,WAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,QAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'difference'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'difference'
+ * @memberof filters
+ */
+export declare class DifferenceBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class DifferenceBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+DifferenceBlend.extension = {
+  name: "difference",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.DifferenceBlend = DifferenceBlend;
+//# sourceMappingURL=DifferenceBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DifferenceBlend.js","sources":["../../src/advanced-blend-modes/DifferenceBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'difference'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'difference'\n * @memberof filters\n */\nexport class DifferenceBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'difference',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)\n                {\n                    return (abs(blend - base) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (abs(blend - base) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAeO,MAAM,wBAAwBA,+BACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.mjs

@@ -0,0 +1,40 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class DifferenceBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (abs(blend - base) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+DifferenceBlend.extension = {
+  name: "difference",
+  type: ExtensionType.BlendMode
+};
+
+export { DifferenceBlend };
+//# sourceMappingURL=DifferenceBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/DifferenceBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DifferenceBlend.mjs","sources":["../../src/advanced-blend-modes/DifferenceBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'difference'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'difference'\n * @memberof filters\n */\nexport class DifferenceBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'difference',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendDifference(vec3 base, vec3 blend,  float opacity)\n                {\n                    return (abs(blend - base) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendDifference(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn blendDifference(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (abs(blend - base) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendDifference(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAeO,MAAM,wBAAwB,eACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Divides the blend from the base color using each color channel
+ * Available as `container.blendMode = 'divide'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'divide'
+ * @memberof filters
+ */
+export declare class DivideBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class DivideBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float divide(float base, float blend)
+                {
+                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;
+                }
+
+                vec3 blendDivide(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn divide(base: f32, blend: f32) -> f32
+                {
+                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);
+                }
+
+                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+DivideBlend.extension = {
+  name: "divide",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.DivideBlend = DivideBlend;
+//# sourceMappingURL=DivideBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DivideBlend.js","sources":["../../src/advanced-blend-modes/DivideBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Divides the blend from the base color using each color channel\n * Available as `container.blendMode = 'divide'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'divide'\n * @memberof filters\n */\nexport class DivideBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'divide',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float divide(float base, float blend)\n                {\n                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;\n                }\n\n                vec3 blendDivide(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        divide(base.r, blend.r),\n                        divide(base.g, blend.g),\n                        divide(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn divide(base: f32, blend: f32) -> f32\n                {\n                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);\n                }\n\n                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        divide(base.r, blend.r),\n                        divide(base.g, blend.g),\n                        divide(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAkBO,MAAM,oBAAoBA,+BACjC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAxDa,WAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,QAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.mjs

@@ -0,0 +1,61 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class DivideBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float divide(float base, float blend)
+                {
+                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;
+                }
+
+                vec3 blendDivide(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn divide(base: f32, blend: f32) -> f32
+                {
+                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);
+                }
+
+                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        divide(base.r, blend.r),
+                        divide(base.g, blend.g),
+                        divide(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+DivideBlend.extension = {
+  name: "divide",
+  type: ExtensionType.BlendMode
+};
+
+export { DivideBlend };
+//# sourceMappingURL=DivideBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/DivideBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DivideBlend.mjs","sources":["../../src/advanced-blend-modes/DivideBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Divides the blend from the base color using each color channel\n * Available as `container.blendMode = 'divide'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'divide'\n * @memberof filters\n */\nexport class DivideBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'divide',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float divide(float base, float blend)\n                {\n                    return (blend > 0.0) ? clamp(base / blend, 0.0, 1.0) : 1.0;\n                }\n\n                vec3 blendDivide(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        divide(base.r, blend.r),\n                        divide(base.g, blend.g),\n                        divide(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendDivide(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn divide(base: f32, blend: f32) -> f32\n                {\n                    return select(1.0, clamp(base / blend, 0.0, 1.0), blend > 0.0);\n                }\n\n                fn blendDivide(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        divide(base.r, blend.r),\n                        divide(base.g, blend.g),\n                        divide(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendDivide(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAkBO,MAAM,oBAAoB,eACjC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAxDa,WAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,QAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ExclusionBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'exclusion'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'exclusion'
+ * @memberof filters
+ */
+export declare class ExclusionBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/ExclusionBlend.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class ExclusionBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 exclusion(vec3 base, vec3 blend)
+                {
+                    return base + blend - 2.0 * base * blend;
+                }
+
+                vec3 blendExclusion(vec3 base, vec3 blend, float opacity)
+                {
+                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendExclusion(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn exclusion(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>
+                {
+                    return base+blend-2.0*base*blend;
+                }
+
+                fn blendExclusion(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendExclusion(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+ExclusionBlend.extension = {
+  name: "exclusion",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.ExclusionBlend = ExclusionBlend;
+//# sourceMappingURL=ExclusionBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/ExclusionBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExclusionBlend.js","sources":["../../src/advanced-blend-modes/ExclusionBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'exclusion'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'exclusion'\n * @memberof filters\n */\nexport class ExclusionBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'exclusion',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 exclusion(vec3 base, vec3 blend)\n                {\n                    return base + blend - 2.0 * base * blend;\n                }\n\n                vec3 blendExclusion(vec3 base, vec3 blend, float opacity)\n                {\n                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendExclusion(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn exclusion(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>\n                {\n                    return base+blend-2.0*base*blend;\n                }\n\n                fn blendExclusion(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendExclusion(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAeO,MAAM,uBAAuBA,+BACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAWX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAWX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AA7Ca,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,WAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/ExclusionBlend.mjs

@@ -0,0 +1,50 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class ExclusionBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 exclusion(vec3 base, vec3 blend)
+                {
+                    return base + blend - 2.0 * base * blend;
+                }
+
+                vec3 blendExclusion(vec3 base, vec3 blend, float opacity)
+                {
+                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendExclusion(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn exclusion(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>
+                {
+                    return base+blend-2.0*base*blend;
+                }
+
+                fn blendExclusion(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendExclusion(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+ExclusionBlend.extension = {
+  name: "exclusion",
+  type: ExtensionType.BlendMode
+};
+
+export { ExclusionBlend };
+//# sourceMappingURL=ExclusionBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/ExclusionBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExclusionBlend.mjs","sources":["../../src/advanced-blend-modes/ExclusionBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'exclusion'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'exclusion'\n * @memberof filters\n */\nexport class ExclusionBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'exclusion',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 exclusion(vec3 base, vec3 blend)\n                {\n                    return base + blend - 2.0 * base * blend;\n                }\n\n                vec3 blendExclusion(vec3 base, vec3 blend, float opacity)\n                {\n                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendExclusion(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn exclusion(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>\n                {\n                    return base+blend-2.0*base*blend;\n                }\n\n                fn blendExclusion(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    return (exclusion(base, blend) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendExclusion(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAeO,MAAM,uBAAuB,eACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAWX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAWX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AA7Ca,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,WAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/HardLightBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'hard-light'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'hard-light'
+ * @memberof filters
+ */
+export declare class HardLightBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/HardLightBlend.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class HardLightBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float hardLight(float base, float blend)
+                {
+                    return (blend < 0.5) ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);
+                }
+
+                vec3 blendHardLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        hardLight(base.r, blend.r),
+                        hardLight(base.g, blend.g),
+                        hardLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendHardLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn hardLight(base: f32, blend: f32) -> f32
+                {
+                    return select(1.0 - 2.0 * (1.0 - base) * (1.0 - blend), 2.0 * base * blend, blend < 0.5);
+                }
+
+                fn blendHardLight(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        hardLight(base.r, blend.r),
+                        hardLight(base.g, blend.g),
+                        hardLight(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendHardLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+HardLightBlend.extension = {
+  name: "hard-light",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.HardLightBlend = HardLightBlend;
+//# sourceMappingURL=HardLightBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/HardLightBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HardLightBlend.js","sources":["../../src/advanced-blend-modes/HardLightBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'hard-light'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'hard-light'\n * @memberof filters\n */\nexport class HardLightBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'hard-light',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float hardLight(float base, float blend)\n                {\n                    return (blend < 0.5) ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);\n                }\n\n                vec3 blendHardLight(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        hardLight(base.r, blend.r),\n                        hardLight(base.g, blend.g),\n                        hardLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendHardLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn hardLight(base: f32, blend: f32) -> f32\n                {\n                    return select(1.0 - 2.0 * (1.0 - base) * (1.0 - blend), 2.0 * base * blend, blend < 0.5);\n                }\n\n                fn blendHardLight(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        hardLight(base.r, blend.r),\n                        hardLight(base.g, blend.g),\n                        hardLight(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendHardLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAiBO,MAAM,uBAAuBA,+BACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAxDa,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/HardLightBlend.mjs

@@ -0,0 +1,61 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class HardLightBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float hardLight(float base, float blend)
+                {
+                    return (blend < 0.5) ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);
+                }
+
+                vec3 blendHardLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        hardLight(base.r, blend.r),
+                        hardLight(base.g, blend.g),
+                        hardLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendHardLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn hardLight(base: f32, blend: f32) -> f32
+                {
+                    return select(1.0 - 2.0 * (1.0 - base) * (1.0 - blend), 2.0 * base * blend, blend < 0.5);
+                }
+
+                fn blendHardLight(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        hardLight(base.r, blend.r),
+                        hardLight(base.g, blend.g),
+                        hardLight(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendHardLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+HardLightBlend.extension = {
+  name: "hard-light",
+  type: ExtensionType.BlendMode
+};
+
+export { HardLightBlend };
+//# sourceMappingURL=HardLightBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/HardLightBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HardLightBlend.mjs","sources":["../../src/advanced-blend-modes/HardLightBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'hard-light'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'hard-light'\n * @memberof filters\n */\nexport class HardLightBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'hard-light',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float hardLight(float base, float blend)\n                {\n                    return (blend < 0.5) ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);\n                }\n\n                vec3 blendHardLight(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        hardLight(base.r, blend.r),\n                        hardLight(base.g, blend.g),\n                        hardLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendHardLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn hardLight(base: f32, blend: f32) -> f32\n                {\n                    return select(1.0 - 2.0 * (1.0 - base) * (1.0 - blend), 2.0 * base * blend, blend < 0.5);\n                }\n\n                fn blendHardLight(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        hardLight(base.r, blend.r),\n                        hardLight(base.g, blend.g),\n                        hardLight(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendHardLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAiBO,MAAM,uBAAuB,eACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAxDa,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/HardMixBlend.d.ts

@@ -0,0 +1,20 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Hard defines each of the color channel values of the blend color to the RGB values of the base color.
+ * If the sum of a channel is 255, it receives a value of 255; if less than 255, a value of 0.
+ *
+ * Available as `container.blendMode = 'hard-mix'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'hard-mix'
+ * @memberof filters
+ */
+export declare class HardMixBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/HardMixBlend.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class HardMixBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float hardMix(float base, float blend)
+                {
+                    return (base + blend >= 1.0) ? 1.0 : 0.0;
+                }
+
+                vec3 blendHardMix(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blended = vec3(
+                        hardMix(base.r, blend.r),
+                        hardMix(base.g, blend.g),
+                        hardMix(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendHardMix(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn hardMix(base: f32, blend: f32) -> f32
+                {
+                    return select(0.0, 1.0, base + blend >= 1.0);
+                }
+
+                fn blendHardMix(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended: vec3<f32> = vec3<f32>(
+                        hardMix(base.r, blend.r),
+                        hardMix(base.g, blend.g),
+                        hardMix(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendHardMix(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+HardMixBlend.extension = {
+  name: "hard-mix",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.HardMixBlend = HardMixBlend;
+//# sourceMappingURL=HardMixBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/HardMixBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HardMixBlend.js","sources":["../../src/advanced-blend-modes/HardMixBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Hard defines each of the color channel values of the blend color to the RGB values of the base color.\n * If the sum of a channel is 255, it receives a value of 255; if less than 255, a value of 0.\n *\n * Available as `container.blendMode = 'hard-mix'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'hard-mix'\n * @memberof filters\n */\nexport class HardMixBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'hard-mix',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float hardMix(float base, float blend)\n                {\n                    return (base + blend >= 1.0) ? 1.0 : 0.0;\n                }\n\n                vec3 blendHardMix(vec3 base, vec3 blend,  float opacity)\n                {\n                    vec3 blended = vec3(\n                        hardMix(base.r, blend.r),\n                        hardMix(base.g, blend.g),\n                        hardMix(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendHardMix(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn hardMix(base: f32, blend: f32) -> f32\n                {\n                    return select(0.0, 1.0, base + blend >= 1.0);\n                }\n\n                fn blendHardMix(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended: vec3<f32> = vec3<f32>(\n                        hardMix(base.r, blend.r),\n                        hardMix(base.g, blend.g),\n                        hardMix(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendHardMix(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAoBO,MAAM,qBAAqBA,+BAClC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAvDa,YAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,UAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/HardMixBlend.mjs

@@ -0,0 +1,60 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class HardMixBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float hardMix(float base, float blend)
+                {
+                    return (base + blend >= 1.0) ? 1.0 : 0.0;
+                }
+
+                vec3 blendHardMix(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blended = vec3(
+                        hardMix(base.r, blend.r),
+                        hardMix(base.g, blend.g),
+                        hardMix(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendHardMix(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                fn hardMix(base: f32, blend: f32) -> f32
+                {
+                    return select(0.0, 1.0, base + blend >= 1.0);
+                }
+
+                fn blendHardMix(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended: vec3<f32> = vec3<f32>(
+                        hardMix(base.r, blend.r),
+                        hardMix(base.g, blend.g),
+                        hardMix(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendHardMix(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+HardMixBlend.extension = {
+  name: "hard-mix",
+  type: ExtensionType.BlendMode
+};
+
+export { HardMixBlend };
+//# sourceMappingURL=HardMixBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/HardMixBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HardMixBlend.mjs","sources":["../../src/advanced-blend-modes/HardMixBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Hard defines each of the color channel values of the blend color to the RGB values of the base color.\n * If the sum of a channel is 255, it receives a value of 255; if less than 255, a value of 0.\n *\n * Available as `container.blendMode = 'hard-mix'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'hard-mix'\n * @memberof filters\n */\nexport class HardMixBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'hard-mix',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float hardMix(float base, float blend)\n                {\n                    return (base + blend >= 1.0) ? 1.0 : 0.0;\n                }\n\n                vec3 blendHardMix(vec3 base, vec3 blend,  float opacity)\n                {\n                    vec3 blended = vec3(\n                        hardMix(base.r, blend.r),\n                        hardMix(base.g, blend.g),\n                        hardMix(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendHardMix(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                fn hardMix(base: f32, blend: f32) -> f32\n                {\n                    return select(0.0, 1.0, base + blend >= 1.0);\n                }\n\n                fn blendHardMix(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended: vec3<f32> = vec3<f32>(\n                        hardMix(base.r, blend.r),\n                        hardMix(base.g, blend.g),\n                        hardMix(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendHardMix(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAoBO,MAAM,qBAAqB,eAClC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAgBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAvDa,YAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,UAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LightenBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'lighten'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'lighten'
+ * @memberof filters
+ */
+export declare class LightenBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/LightenBlend.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class LightenBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendLighten(vec3 base, vec3 blend, float opacity)
+                {
+                    return (max(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendLighten(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn blendLighten(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (max(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendLighten(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+LightenBlend.extension = {
+  name: "lighten",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.LightenBlend = LightenBlend;
+//# sourceMappingURL=LightenBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/LightenBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightenBlend.js","sources":["../../src/advanced-blend-modes/LightenBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'lighten'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'lighten'\n * @memberof filters\n */\nexport class LightenBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'lighten',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendLighten(vec3 base, vec3 blend, float opacity)\n                {\n                    return (max(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendLighten(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn blendLighten(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (max(base, blend) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendLighten(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAeO,MAAM,qBAAqBA,+BAClC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,YAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,SAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LightenBlend.mjs

@@ -0,0 +1,40 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class LightenBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 blendLighten(vec3 base, vec3 blend, float opacity)
+                {
+                    return (max(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendLighten(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn blendLighten(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    return (max(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendLighten(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+LightenBlend.extension = {
+  name: "lighten",
+  type: ExtensionType.BlendMode
+};
+
+export { LightenBlend };
+//# sourceMappingURL=LightenBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/LightenBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightenBlend.mjs","sources":["../../src/advanced-blend-modes/LightenBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'lighten'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'lighten'\n * @memberof filters\n */\nexport class LightenBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'lighten',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 blendLighten(vec3 base, vec3 blend, float opacity)\n                {\n                    return (max(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendLighten(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn blendLighten(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    return (max(base, blend) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendLighten(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAeO,MAAM,qBAAqB,eAClC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAMX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAnCa,YAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,SAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LinearBurnBlend.d.ts

@@ -0,0 +1,20 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Looks at the color information in each channel and darkens the base color to
+ * reflect the blend color by increasing the contrast between the two.
+ *
+ * Available as `container.blendMode = 'linear-burn'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'linear-burn'
+ * @memberof filters
+ */
+export declare class LinearBurnBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/LinearBurnBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class LinearBurnBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float linearBurn(float base, float blend)
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                vec3 blendLinearBurn(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        linearBurn(base.r, blend.r),
+                        linearBurn(base.g, blend.g),
+                        linearBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendLinearBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn linearBurn(base: f32, blend: f32) -> f32
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                fn blendLinearBurn(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearBurn(base.r, blend.r),
+                        linearBurn(base.g, blend.g),
+                        linearBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendLinearBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+LinearBurnBlend.extension = {
+  name: "linear-burn",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.LinearBurnBlend = LinearBurnBlend;
+//# sourceMappingURL=LinearBurnBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/LinearBurnBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinearBurnBlend.js","sources":["../../src/advanced-blend-modes/LinearBurnBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and darkens the base color to\n * reflect the blend color by increasing the contrast between the two.\n *\n * Available as `container.blendMode = 'linear-burn'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'linear-burn'\n * @memberof filters\n */\nexport class LinearBurnBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'linear-burn',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float linearBurn(float base, float blend)\n                {\n                    return max(0.0, base + blend - 1.0);\n                }\n\n                vec3 blendLinearBurn(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        linearBurn(base.r, blend.r),\n                        linearBurn(base.g, blend.g),\n                        linearBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendLinearBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn linearBurn(base: f32, blend: f32) -> f32\n                {\n                    return max(0.0, base + blend - 1.0);\n                }\n\n                fn blendLinearBurn(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        linearBurn(base.r, blend.r),\n                        linearBurn(base.g, blend.g),\n                        linearBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendLinearBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAoBO,MAAM,wBAAwBA,+BACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,aAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LinearBurnBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class LinearBurnBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float linearBurn(float base, float blend)
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                vec3 blendLinearBurn(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        linearBurn(base.r, blend.r),
+                        linearBurn(base.g, blend.g),
+                        linearBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendLinearBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn linearBurn(base: f32, blend: f32) -> f32
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                fn blendLinearBurn(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearBurn(base.r, blend.r),
+                        linearBurn(base.g, blend.g),
+                        linearBurn(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendLinearBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+LinearBurnBlend.extension = {
+  name: "linear-burn",
+  type: ExtensionType.BlendMode
+};
+
+export { LinearBurnBlend };
+//# sourceMappingURL=LinearBurnBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/LinearBurnBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinearBurnBlend.mjs","sources":["../../src/advanced-blend-modes/LinearBurnBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and darkens the base color to\n * reflect the blend color by increasing the contrast between the two.\n *\n * Available as `container.blendMode = 'linear-burn'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'linear-burn'\n * @memberof filters\n */\nexport class LinearBurnBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'linear-burn',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float linearBurn(float base, float blend)\n                {\n                    return max(0.0, base + blend - 1.0);\n                }\n\n                vec3 blendLinearBurn(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        linearBurn(base.r, blend.r),\n                        linearBurn(base.g, blend.g),\n                        linearBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendLinearBurn(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn linearBurn(base: f32, blend: f32) -> f32\n                {\n                    return max(0.0, base + blend - 1.0);\n                }\n\n                fn blendLinearBurn(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        linearBurn(base.r, blend.r),\n                        linearBurn(base.g, blend.g),\n                        linearBurn(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendLinearBurn(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAoBO,MAAM,wBAAwB,eACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,aAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LinearDodgeBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.
+ * Available as `container.blendMode = 'linear-dodge'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'linear-dodge'
+ * @memberof filters
+ */
+export declare class LinearDodgeBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/LinearDodgeBlend.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class LinearDodgeBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float linearDodge(float base, float blend) {
+                    return min(1.0, base + blend);
+                }
+
+                vec3 blendLinearDodge(vec3 base, vec3 blend, float opacity) {
+                    vec3 blended = vec3(
+                        linearDodge(base.r, blend.r),
+                        linearDodge(base.g, blend.g),
+                        linearDodge(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendLinearDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn linearDodge(base: f32, blend: f32) -> f32
+                {
+                    return min(1, base + blend);
+                }
+
+                fn blendLinearDodge(base:vec3<f32>, blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearDodge(base.r, blend.r),
+                        linearDodge(base.g, blend.g),
+                        linearDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendLinearDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+LinearDodgeBlend.extension = {
+  name: "linear-dodge",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.LinearDodgeBlend = LinearDodgeBlend;
+//# sourceMappingURL=LinearDodgeBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/LinearDodgeBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinearDodgeBlend.js","sources":["../../src/advanced-blend-modes/LinearDodgeBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.\n * Available as `container.blendMode = 'linear-dodge'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'linear-dodge'\n * @memberof filters\n */\nexport class LinearDodgeBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'linear-dodge',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float linearDodge(float base, float blend) {\n                    return min(1.0, base + blend);\n                }\n\n                vec3 blendLinearDodge(vec3 base, vec3 blend, float opacity) {\n                    vec3 blended = vec3(\n                        linearDodge(base.r, blend.r),\n                        linearDodge(base.g, blend.g),\n                        linearDodge(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendLinearDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn linearDodge(base: f32, blend: f32) -> f32\n                {\n                    return min(1, base + blend);\n                }\n\n                fn blendLinearDodge(base:vec3<f32>, blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        linearDodge(base.r, blend.r),\n                        linearDodge(base.g, blend.g),\n                        linearDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendLinearDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAkBO,MAAM,yBAAyBA,+BACtC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAcX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAtDa,gBAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,cAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LinearDodgeBlend.mjs

@@ -0,0 +1,59 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class LinearDodgeBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float linearDodge(float base, float blend) {
+                    return min(1.0, base + blend);
+                }
+
+                vec3 blendLinearDodge(vec3 base, vec3 blend, float opacity) {
+                    vec3 blended = vec3(
+                        linearDodge(base.r, blend.r),
+                        linearDodge(base.g, blend.g),
+                        linearDodge(base.b, blend.b)
+                    );
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendLinearDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn linearDodge(base: f32, blend: f32) -> f32
+                {
+                    return min(1, base + blend);
+                }
+
+                fn blendLinearDodge(base:vec3<f32>, blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearDodge(base.r, blend.r),
+                        linearDodge(base.g, blend.g),
+                        linearDodge(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendLinearDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+LinearDodgeBlend.extension = {
+  name: "linear-dodge",
+  type: ExtensionType.BlendMode
+};
+
+export { LinearDodgeBlend };
+//# sourceMappingURL=LinearDodgeBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/LinearDodgeBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinearDodgeBlend.mjs","sources":["../../src/advanced-blend-modes/LinearDodgeBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Looks at the color information in each channel and brightens the base color to reflect the blend color by decreasing contrast between the two.\n * Available as `container.blendMode = 'linear-dodge'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'linear-dodge'\n * @memberof filters\n */\nexport class LinearDodgeBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'linear-dodge',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float linearDodge(float base, float blend) {\n                    return min(1.0, base + blend);\n                }\n\n                vec3 blendLinearDodge(vec3 base, vec3 blend, float opacity) {\n                    vec3 blended = vec3(\n                        linearDodge(base.r, blend.r),\n                        linearDodge(base.g, blend.g),\n                        linearDodge(base.b, blend.b)\n                    );\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendLinearDodge(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn linearDodge(base: f32, blend: f32) -> f32\n                {\n                    return min(1, base + blend);\n                }\n\n                fn blendLinearDodge(base:vec3<f32>, blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        linearDodge(base.r, blend.r),\n                        linearDodge(base.g, blend.g),\n                        linearDodge(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendLinearDodge(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAkBO,MAAM,yBAAyB,eACtC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAcX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAtDa,gBAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,cAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LinearLightBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Increase or decrease brightness by burning or dodging color values, based on the blend color
+ * Available as `container.blendMode = 'linear-light'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'linear-light'
+ * @memberof filters
+ */
+export declare class LinearLightBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/LinearLightBlend.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class LinearLightBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float linearBurn(float base, float blend) {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                float linearDodge(float base, float blend) {
+                    return min(1.0, base + blend);
+                }
+
+                float linearLight(float base, float blend) {
+                    return (blend <= 0.5) ? linearBurn(base,2.0*blend) : linearBurn(base,2.0*(blend-0.5));
+                }
+
+                vec3 blendLinearLight(vec3 base, vec3 blend, float opacity) {
+                    vec3 blended = vec3(
+                        linearLight(base.r, blend.r),
+                        linearLight(base.g, blend.g),
+                        linearLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendLinearLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn linearBurn(base: f32, blend: f32) -> f32
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                fn linearDodge(base: f32, blend: f32) -> f32
+                {
+                    return min(1.0, base + blend);
+                }
+
+                fn linearLight(base: f32, blend: f32) -> f32
+                {
+                    return select(linearBurn(base,2.0*(blend-0.5)), linearBurn(base,2.0*blend), blend <= 0.5);
+                }
+
+                fn blendLinearLightOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearLight(base.r, blend.r),
+                        linearLight(base.g, blend.g),
+                        linearLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendLinearLightOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+LinearLightBlend.extension = {
+  name: "linear-light",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.LinearLightBlend = LinearLightBlend;
+//# sourceMappingURL=LinearLightBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/LinearLightBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinearLightBlend.js","sources":["../../src/advanced-blend-modes/LinearLightBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Increase or decrease brightness by burning or dodging color values, based on the blend color\n * Available as `container.blendMode = 'linear-light'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'linear-light'\n * @memberof filters\n */\nexport class LinearLightBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'linear-light',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float linearBurn(float base, float blend) {\n                    return max(0.0, base + blend - 1.0);\n                }\n\n                float linearDodge(float base, float blend) {\n                    return min(1.0, base + blend);\n                }\n\n                float linearLight(float base, float blend) {\n                    return (blend <= 0.5) ? linearBurn(base,2.0*blend) : linearBurn(base,2.0*(blend-0.5));\n                }\n\n                vec3 blendLinearLight(vec3 base, vec3 blend, float opacity) {\n                    vec3 blended = vec3(\n                        linearLight(base.r, blend.r),\n                        linearLight(base.g, blend.g),\n                        linearLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendLinearLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn linearBurn(base: f32, blend: f32) -> f32\n                {\n                    return max(0.0, base + blend - 1.0);\n                }\n\n                fn linearDodge(base: f32, blend: f32) -> f32\n                {\n                    return min(1.0, base + blend);\n                }\n\n                fn linearLight(base: f32, blend: f32) -> f32\n                {\n                    return select(linearBurn(base,2.0*(blend-0.5)), linearBurn(base,2.0*blend), blend <= 0.5);\n                }\n\n                fn blendLinearLightOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        linearLight(base.r, blend.r),\n                        linearLight(base.g, blend.g),\n                        linearLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendLinearLightOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAkBO,MAAM,yBAAyBA,+BACtC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAuBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QA2BX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzEa,gBAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,cAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LinearLightBlend.mjs

@@ -0,0 +1,78 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class LinearLightBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float linearBurn(float base, float blend) {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                float linearDodge(float base, float blend) {
+                    return min(1.0, base + blend);
+                }
+
+                float linearLight(float base, float blend) {
+                    return (blend <= 0.5) ? linearBurn(base,2.0*blend) : linearBurn(base,2.0*(blend-0.5));
+                }
+
+                vec3 blendLinearLight(vec3 base, vec3 blend, float opacity) {
+                    vec3 blended = vec3(
+                        linearLight(base.r, blend.r),
+                        linearLight(base.g, blend.g),
+                        linearLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendLinearLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn linearBurn(base: f32, blend: f32) -> f32
+                {
+                    return max(0.0, base + blend - 1.0);
+                }
+
+                fn linearDodge(base: f32, blend: f32) -> f32
+                {
+                    return min(1.0, base + blend);
+                }
+
+                fn linearLight(base: f32, blend: f32) -> f32
+                {
+                    return select(linearBurn(base,2.0*(blend-0.5)), linearBurn(base,2.0*blend), blend <= 0.5);
+                }
+
+                fn blendLinearLightOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        linearLight(base.r, blend.r),
+                        linearLight(base.g, blend.g),
+                        linearLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendLinearLightOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+LinearLightBlend.extension = {
+  name: "linear-light",
+  type: ExtensionType.BlendMode
+};
+
+export { LinearLightBlend };
+//# sourceMappingURL=LinearLightBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/LinearLightBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinearLightBlend.mjs","sources":["../../src/advanced-blend-modes/LinearLightBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Increase or decrease brightness by burning or dodging color values, based on the blend color\n * Available as `container.blendMode = 'linear-light'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'linear-light'\n * @memberof filters\n */\nexport class LinearLightBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'linear-light',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float linearBurn(float base, float blend) {\n                    return max(0.0, base + blend - 1.0);\n                }\n\n                float linearDodge(float base, float blend) {\n                    return min(1.0, base + blend);\n                }\n\n                float linearLight(float base, float blend) {\n                    return (blend <= 0.5) ? linearBurn(base,2.0*blend) : linearBurn(base,2.0*(blend-0.5));\n                }\n\n                vec3 blendLinearLight(vec3 base, vec3 blend, float opacity) {\n                    vec3 blended = vec3(\n                        linearLight(base.r, blend.r),\n                        linearLight(base.g, blend.g),\n                        linearLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendLinearLight(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn linearBurn(base: f32, blend: f32) -> f32\n                {\n                    return max(0.0, base + blend - 1.0);\n                }\n\n                fn linearDodge(base: f32, blend: f32) -> f32\n                {\n                    return min(1.0, base + blend);\n                }\n\n                fn linearLight(base: f32, blend: f32) -> f32\n                {\n                    return select(linearBurn(base,2.0*(blend-0.5)), linearBurn(base,2.0*blend), blend <= 0.5);\n                }\n\n                fn blendLinearLightOpacity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        linearLight(base.r, blend.r),\n                        linearLight(base.g, blend.g),\n                        linearLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendLinearLightOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAkBO,MAAM,yBAAyB,eACtC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAuBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QA2BX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzEa,gBAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,cAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LuminosityBlend.d.ts

@@ -0,0 +1,17 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'luminosity'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'luminosity'
+ * @memberof filters
+ */
+export declare class LuminosityBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/LuminosityBlend.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+var GLhls = require('../filters/blend-modes/hls/GLhls.js');
+var GPUhls = require('../filters/blend-modes/hls/GPUhls.js');
+
+"use strict";
+class LuminosityBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                ${GLhls.hslgl}
+
+                vec3 blendLuminosity(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blendLuminosity = setLuminosity(base, getLuminosity(blend));
+                    return (blendLuminosity * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendLuminosity(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                ${GPUhls.hslgpu}
+
+                fn blendLuminosity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blendLuminosity: vec3<f32> = setLuminosity(base, getLuminosity(blend));
+                    return (blendLuminosity * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendLuminosity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+LuminosityBlend.extension = {
+  name: "luminosity",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.LuminosityBlend = LuminosityBlend;
+//# sourceMappingURL=LuminosityBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/LuminosityBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LuminosityBlend.js","sources":["../../src/advanced-blend-modes/LuminosityBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\nimport { hslgl } from '../filters/blend-modes/hls/GLhls';\nimport { hslgpu } from '../filters/blend-modes/hls/GPUhls';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'luminosity'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'luminosity'\n * @memberof filters\n */\nexport class LuminosityBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'luminosity',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                ${hslgl}\n\n                vec3 blendLuminosity(vec3 base, vec3 blend,  float opacity)\n                {\n                    vec3 blendLuminosity = setLuminosity(base, getLuminosity(blend));\n                    return (blendLuminosity * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendLuminosity(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                ${hslgpu}\n\n                fn blendLuminosity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blendLuminosity: vec3<f32> = setLuminosity(base, getLuminosity(blend));\n                    return (blendLuminosity * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendLuminosity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","hslgl","hslgpu","ExtensionType"],"mappings":";;;;;;;;AAiBO,MAAM,wBAAwBA,+BACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA,gBAAA,EACTC,WAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAQP,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA,gBAAA,EACTC,aAAM,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAQR,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzCa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/LuminosityBlend.mjs

@@ -0,0 +1,48 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+import { hslgl } from '../filters/blend-modes/hls/GLhls.mjs';
+import { hslgpu } from '../filters/blend-modes/hls/GPUhls.mjs';
+
+"use strict";
+class LuminosityBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                ${hslgl}
+
+                vec3 blendLuminosity(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blendLuminosity = setLuminosity(base, getLuminosity(blend));
+                    return (blendLuminosity * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendLuminosity(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                ${hslgpu}
+
+                fn blendLuminosity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blendLuminosity: vec3<f32> = setLuminosity(base, getLuminosity(blend));
+                    return (blendLuminosity * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendLuminosity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+LuminosityBlend.extension = {
+  name: "luminosity",
+  type: ExtensionType.BlendMode
+};
+
+export { LuminosityBlend };
+//# sourceMappingURL=LuminosityBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/LuminosityBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LuminosityBlend.mjs","sources":["../../src/advanced-blend-modes/LuminosityBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\nimport { hslgl } from '../filters/blend-modes/hls/GLhls';\nimport { hslgpu } from '../filters/blend-modes/hls/GPUhls';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'luminosity'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'luminosity'\n * @memberof filters\n */\nexport class LuminosityBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'luminosity',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                ${hslgl}\n\n                vec3 blendLuminosity(vec3 base, vec3 blend,  float opacity)\n                {\n                    vec3 blendLuminosity = setLuminosity(base, getLuminosity(blend));\n                    return (blendLuminosity * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendLuminosity(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                ${hslgpu}\n\n                fn blendLuminosity(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blendLuminosity: vec3<f32> = setLuminosity(base, getLuminosity(blend));\n                    return (blendLuminosity * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendLuminosity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;;;AAiBO,MAAM,wBAAwB,eACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA,gBAAA,EACT,KAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAQP,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA,gBAAA,EACT,MAAM,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAQR,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzCa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/NegationBlend.d.ts

@@ -0,0 +1,16 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'negation'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'negation'
+ */
+export declare class NegationBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/NegationBlend.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class NegationBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 negation(vec3 base, vec3 blend)
+                {
+                    return 1.0-abs(1.0-base-blend);
+                }
+
+                vec3 blendNegation(vec3 base, vec3 blend, float opacity)
+                {
+                    return (negation(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendNegation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn blendNegation(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>
+                {
+                    return 1.0-abs(1.0-base-blend);
+                }
+
+                fn blendNegationOpacity(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    return (blendNegation(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendNegationOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+NegationBlend.extension = {
+  name: "negation",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.NegationBlend = NegationBlend;
+//# sourceMappingURL=NegationBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/NegationBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NegationBlend.js","sources":["../../src/advanced-blend-modes/NegationBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'negation'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'negation'\n */\nexport class NegationBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'negation',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 negation(vec3 base, vec3 blend)\n                {\n                    return 1.0-abs(1.0-base-blend);\n                }\n\n                vec3 blendNegation(vec3 base, vec3 blend, float opacity)\n                {\n                    return (negation(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendNegation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn blendNegation(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>\n                {\n                    return 1.0-abs(1.0-base-blend);\n                }\n\n                fn blendNegationOpacity(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    return (blendNegation(base, blend) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendNegationOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAcO,MAAM,sBAAsBA,+BACnC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAWX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAWX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AA7Ca,aAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,UAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/NegationBlend.mjs

@@ -0,0 +1,50 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class NegationBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                vec3 negation(vec3 base, vec3 blend)
+                {
+                    return 1.0-abs(1.0-base-blend);
+                }
+
+                vec3 blendNegation(vec3 base, vec3 blend, float opacity)
+                {
+                    return (negation(base, blend) * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendNegation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn blendNegation(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>
+                {
+                    return 1.0-abs(1.0-base-blend);
+                }
+
+                fn blendNegationOpacity(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    return (blendNegation(base, blend) * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendNegationOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+NegationBlend.extension = {
+  name: "negation",
+  type: ExtensionType.BlendMode
+};
+
+export { NegationBlend };
+//# sourceMappingURL=NegationBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/NegationBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"NegationBlend.mjs","sources":["../../src/advanced-blend-modes/NegationBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'negation'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'negation'\n */\nexport class NegationBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'negation',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                vec3 negation(vec3 base, vec3 blend)\n                {\n                    return 1.0-abs(1.0-base-blend);\n                }\n\n                vec3 blendNegation(vec3 base, vec3 blend, float opacity)\n                {\n                    return (negation(base, blend) * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendNegation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn blendNegation(base: vec3<f32>, blend: vec3<f32>) -> vec3<f32>\n                {\n                    return 1.0-abs(1.0-base-blend);\n                }\n\n                fn blendNegationOpacity(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    return (blendNegation(base, blend) * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendNegationOpacity(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAcO,MAAM,sBAAsB,eACnC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAWX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAWX,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AA7Ca,aAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,UAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/OverlayBlend.d.ts

@@ -0,0 +1,16 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'overlay'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'overlay'
+ */
+export declare class OverlayBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/OverlayBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class OverlayBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float overlay(float base, float blend)
+                {
+                    return (base < 0.5) ? (2.0*base*blend) : (1.0-2.0*(1.0-base)*(1.0-blend));
+                }
+
+                vec3 blendOverlay(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        overlay(base.r, blend.r),
+                        overlay(base.g, blend.g),
+                        overlay(base.b, blend.b)
+                    );
+   
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendOverlay(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn overlay(base: f32, blend: f32) -> f32
+                {
+                    return select((1.0-2.0*(1.0-base)*(1.0-blend)), (2.0*base*blend), base < 0.5);
+                }
+
+                fn blendOverlay(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        overlay(base.r, blend.r),
+                        overlay(base.g, blend.g),
+                        overlay(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendOverlay(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+OverlayBlend.extension = {
+  name: "overlay",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.OverlayBlend = OverlayBlend;
+//# sourceMappingURL=OverlayBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/OverlayBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlayBlend.js","sources":["../../src/advanced-blend-modes/OverlayBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'overlay'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'overlay'\n */\nexport class OverlayBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'overlay',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float overlay(float base, float blend)\n                {\n                    return (base < 0.5) ? (2.0*base*blend) : (1.0-2.0*(1.0-base)*(1.0-blend));\n                }\n\n                vec3 blendOverlay(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        overlay(base.r, blend.r),\n                        overlay(base.g, blend.g),\n                        overlay(base.b, blend.b)\n                    );\n   \n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendOverlay(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `,\n            },\n            gpu: {\n                functions: `\n                fn overlay(base: f32, blend: f32) -> f32\n                {\n                    return select((1.0-2.0*(1.0-base)*(1.0-blend)), (2.0*base*blend), base < 0.5);\n                }\n\n                fn blendOverlay(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        overlay(base.r, blend.r),\n                        overlay(base.g, blend.g),\n                        overlay(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendOverlay(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `,\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAcO,MAAM,qBAAqBA,+BAClC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,YAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,SAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/OverlayBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class OverlayBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float overlay(float base, float blend)
+                {
+                    return (base < 0.5) ? (2.0*base*blend) : (1.0-2.0*(1.0-base)*(1.0-blend));
+                }
+
+                vec3 blendOverlay(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        overlay(base.r, blend.r),
+                        overlay(base.g, blend.g),
+                        overlay(base.b, blend.b)
+                    );
+   
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendOverlay(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn overlay(base: f32, blend: f32) -> f32
+                {
+                    return select((1.0-2.0*(1.0-base)*(1.0-blend)), (2.0*base*blend), base < 0.5);
+                }
+
+                fn blendOverlay(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        overlay(base.r, blend.r),
+                        overlay(base.g, blend.g),
+                        overlay(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendOverlay(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+OverlayBlend.extension = {
+  name: "overlay",
+  type: ExtensionType.BlendMode
+};
+
+export { OverlayBlend };
+//# sourceMappingURL=OverlayBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/OverlayBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlayBlend.mjs","sources":["../../src/advanced-blend-modes/OverlayBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'overlay'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'overlay'\n */\nexport class OverlayBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'overlay',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float overlay(float base, float blend)\n                {\n                    return (base < 0.5) ? (2.0*base*blend) : (1.0-2.0*(1.0-base)*(1.0-blend));\n                }\n\n                vec3 blendOverlay(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        overlay(base.r, blend.r),\n                        overlay(base.g, blend.g),\n                        overlay(base.b, blend.b)\n                    );\n   \n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendOverlay(back.rgb, front.rgb,front.a), blendedAlpha) * uBlend;\n                `,\n            },\n            gpu: {\n                functions: `\n                fn overlay(base: f32, blend: f32) -> f32\n                {\n                    return select((1.0-2.0*(1.0-base)*(1.0-blend)), (2.0*base*blend), base < 0.5);\n                }\n\n                fn blendOverlay(base: vec3<f32>, blend: vec3<f32>, opacity: f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        overlay(base.r, blend.r),\n                        overlay(base.g, blend.g),\n                        overlay(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendOverlay(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `,\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAcO,MAAM,qBAAqB,eAClC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,YAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,SAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/PinLightBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Replaces colors based on the blend color.
+ * Available as `container.blendMode = 'pin-light'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'pin-light'
+ * @memberof filters
+ */
+export declare class PinLightBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/PinLightBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class PinLightBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float pinLight(float base, float blend)
+                {
+                    return (blend <= 0.5) ? min(base, 2.0 * blend) : max(base, 2.0 * (blend - 0.5));
+                }
+
+                vec3 blendPinLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        pinLight(base.r, blend.r),
+                        pinLight(base.g, blend.g),
+                        pinLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn pinLight(base: f32, blend: f32) -> f32
+                {
+                    return select(max(base,2.0*(blend-0.5)), min(base,2.0*blend), blend <= 0.5);
+                }
+
+                fn blendPinLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        pinLight(base.r, blend.r),
+                        pinLight(base.g, blend.g),
+                        pinLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+PinLightBlend.extension = {
+  name: "pin-light",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.PinLightBlend = PinLightBlend;
+//# sourceMappingURL=PinLightBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/PinLightBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PinLightBlend.js","sources":["../../src/advanced-blend-modes/PinLightBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Replaces colors based on the blend color.\n * Available as `container.blendMode = 'pin-light'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'pin-light'\n * @memberof filters\n */\nexport class PinLightBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'pin-light',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float pinLight(float base, float blend)\n                {\n                    return (blend <= 0.5) ? min(base, 2.0 * blend) : max(base, 2.0 * (blend - 0.5));\n                }\n\n                vec3 blendPinLight(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        pinLight(base.r, blend.r),\n                        pinLight(base.g, blend.g),\n                        pinLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn pinLight(base: f32, blend: f32) -> f32\n                {\n                    return select(max(base,2.0*(blend-0.5)), min(base,2.0*blend), blend <= 0.5);\n                }\n\n                fn blendPinLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        pinLight(base.r, blend.r),\n                        pinLight(base.g, blend.g),\n                        pinLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAkBO,MAAM,sBAAsBA,+BACnC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,aAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,WAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/PinLightBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class PinLightBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float pinLight(float base, float blend)
+                {
+                    return (blend <= 0.5) ? min(base, 2.0 * blend) : max(base, 2.0 * (blend - 0.5));
+                }
+
+                vec3 blendPinLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        pinLight(base.r, blend.r),
+                        pinLight(base.g, blend.g),
+                        pinLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn pinLight(base: f32, blend: f32) -> f32
+                {
+                    return select(max(base,2.0*(blend-0.5)), min(base,2.0*blend), blend <= 0.5);
+                }
+
+                fn blendPinLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        pinLight(base.r, blend.r),
+                        pinLight(base.g, blend.g),
+                        pinLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+PinLightBlend.extension = {
+  name: "pin-light",
+  type: ExtensionType.BlendMode
+};
+
+export { PinLightBlend };
+//# sourceMappingURL=PinLightBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/PinLightBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PinLightBlend.mjs","sources":["../../src/advanced-blend-modes/PinLightBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Replaces colors based on the blend color.\n * Available as `container.blendMode = 'pin-light'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'pin-light'\n * @memberof filters\n */\nexport class PinLightBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'pin-light',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float pinLight(float base, float blend)\n                {\n                    return (blend <= 0.5) ? min(base, 2.0 * blend) : max(base, 2.0 * (blend - 0.5));\n                }\n\n                vec3 blendPinLight(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        pinLight(base.r, blend.r),\n                        pinLight(base.g, blend.g),\n                        pinLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn pinLight(base: f32, blend: f32) -> f32\n                {\n                    return select(max(base,2.0*(blend-0.5)), min(base,2.0*blend), blend <= 0.5);\n                }\n\n                fn blendPinLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        pinLight(base.r, blend.r),\n                        pinLight(base.g, blend.g),\n                        pinLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendPinLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAkBO,MAAM,sBAAsB,eACnC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,aAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,WAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/SaturationBlend.d.ts

@@ -0,0 +1,16 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'saturation'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'saturation'
+ */
+export declare class SaturationBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/SaturationBlend.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+var GLhls = require('../filters/blend-modes/hls/GLhls.js');
+var GPUhls = require('../filters/blend-modes/hls/GPUhls.js');
+
+"use strict";
+class SaturationBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                ${GLhls.hslgl}
+
+                vec3 blendSaturation(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));
+                    return (blendSaturation * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                ${GPUhls.hslgpu}
+
+                fn blendSaturation(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));
+                    return (blendSaturation * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+SaturationBlend.extension = {
+  name: "saturation",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.SaturationBlend = SaturationBlend;
+//# sourceMappingURL=SaturationBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/SaturationBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaturationBlend.js","sources":["../../src/advanced-blend-modes/SaturationBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\nimport { hslgl } from '../filters/blend-modes/hls/GLhls';\nimport { hslgpu } from '../filters/blend-modes/hls/GPUhls';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'saturation'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'saturation'\n */\nexport class SaturationBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'saturation',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                ${hslgl}\n\n                vec3 blendSaturation(vec3 base, vec3 blend,  float opacity)\n                {\n                    vec3 blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));\n                    return (blendSaturation * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                ${hslgpu}\n\n                fn blendSaturation(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));\n                    return (blendSaturation * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","hslgl","hslgpu","ExtensionType"],"mappings":";;;;;;;;AAgBO,MAAM,wBAAwBA,+BACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA,gBAAA,EACTC,WAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAQP,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA,gBAAA,EACTC,aAAM,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAQR,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzCa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/SaturationBlend.mjs

@@ -0,0 +1,48 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+import { hslgl } from '../filters/blend-modes/hls/GLhls.mjs';
+import { hslgpu } from '../filters/blend-modes/hls/GPUhls.mjs';
+
+"use strict";
+class SaturationBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                ${hslgl}
+
+                vec3 blendSaturation(vec3 base, vec3 blend,  float opacity)
+                {
+                    vec3 blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));
+                    return (blendSaturation * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                finalColor = vec4(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+            `
+      },
+      gpu: {
+        functions: `
+                ${hslgpu}
+
+                fn blendSaturation(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));
+                    return (blendSaturation * opacity + base * (1.0 - opacity));
+                }
+            `,
+        main: `
+                out = vec4<f32>(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+            `
+      }
+    });
+  }
+}
+/** @ignore */
+SaturationBlend.extension = {
+  name: "saturation",
+  type: ExtensionType.BlendMode
+};
+
+export { SaturationBlend };
+//# sourceMappingURL=SaturationBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/SaturationBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaturationBlend.mjs","sources":["../../src/advanced-blend-modes/SaturationBlend.ts"],"sourcesContent":["import { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\nimport { hslgl } from '../filters/blend-modes/hls/GLhls';\nimport { hslgpu } from '../filters/blend-modes/hls/GPUhls';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'saturation'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'saturation'\n */\nexport class SaturationBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'saturation',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                ${hslgl}\n\n                vec3 blendSaturation(vec3 base, vec3 blend,  float opacity)\n                {\n                    vec3 blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));\n                    return (blendSaturation * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                finalColor = vec4(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n            `\n            },\n            gpu: {\n                functions: `\n                ${hslgpu}\n\n                fn blendSaturation(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blendSaturation = setLuminosity(setSaturation(base, getSaturation(blend)), getLuminosity(base));\n                    return (blendSaturation * opacity + base * (1.0 - opacity));\n                }\n            `,\n                main: `\n                out = vec4<f32>(blendSaturation(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n            `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;;;AAgBO,MAAM,wBAAwB,eACrC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA,gBAAA,EACT,KAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAQP,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA,gBAAA,EACT,MAAM,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAA,CAAA;AAAA,QAQR,IAAM,EAAA,CAAA;AAAA;AAAA,YAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzCa,eAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/SoftLightBlend.d.ts

@@ -0,0 +1,16 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Available as `container.blendMode = 'soft-light'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'soft-light'
+ */
+export declare class SoftLightBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/SoftLightBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class SoftLightBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float softLight(float base, float blend)
+                {
+                    return (blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend));
+                }
+
+                vec3 blendSoftLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        softLight(base.r, blend.r),
+                        softLight(base.g, blend.g),
+                        softLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn softLight(base: f32, blend: f32) -> f32
+                {
+                    return select(2.0 * base * blend + base * base * (1.0 - 2.0 * blend), sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend), blend < 0.5);
+                }
+
+                fn blendSoftLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended: vec3<f32> = vec3<f32>(
+                        softLight(base.r, blend.r),
+                        softLight(base.g, blend.g),
+                        softLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+SoftLightBlend.extension = {
+  name: "soft-light",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.SoftLightBlend = SoftLightBlend;
+//# sourceMappingURL=SoftLightBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/SoftLightBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoftLightBlend.js","sources":["../../src/advanced-blend-modes/SoftLightBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'soft-light'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'soft-light'\n */\nexport class SoftLightBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'soft-light',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float softLight(float base, float blend)\n                {\n                    return (blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend));\n                }\n\n                vec3 blendSoftLight(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        softLight(base.r, blend.r),\n                        softLight(base.g, blend.g),\n                        softLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn softLight(base: f32, blend: f32) -> f32\n                {\n                    return select(2.0 * base * blend + base * base * (1.0 - 2.0 * blend), sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend), blend < 0.5);\n                }\n\n                fn blendSoftLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended: vec3<f32> = vec3<f32>(\n                        softLight(base.r, blend.r),\n                        softLight(base.g, blend.g),\n                        softLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAgBO,MAAM,uBAAuBA,+BACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/SoftLightBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class SoftLightBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float softLight(float base, float blend)
+                {
+                    return (blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend));
+                }
+
+                vec3 blendSoftLight(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        softLight(base.r, blend.r),
+                        softLight(base.g, blend.g),
+                        softLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn softLight(base: f32, blend: f32) -> f32
+                {
+                    return select(2.0 * base * blend + base * base * (1.0 - 2.0 * blend), sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend), blend < 0.5);
+                }
+
+                fn blendSoftLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended: vec3<f32> = vec3<f32>(
+                        softLight(base.r, blend.r),
+                        softLight(base.g, blend.g),
+                        softLight(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+SoftLightBlend.extension = {
+  name: "soft-light",
+  type: ExtensionType.BlendMode
+};
+
+export { SoftLightBlend };
+//# sourceMappingURL=SoftLightBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/SoftLightBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoftLightBlend.mjs","sources":["../../src/advanced-blend-modes/SoftLightBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Available as `container.blendMode = 'soft-light'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'soft-light'\n */\nexport class SoftLightBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'soft-light',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float softLight(float base, float blend)\n                {\n                    return (blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend));\n                }\n\n                vec3 blendSoftLight(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        softLight(base.r, blend.r),\n                        softLight(base.g, blend.g),\n                        softLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn softLight(base: f32, blend: f32) -> f32\n                {\n                    return select(2.0 * base * blend + base * base * (1.0 - 2.0 * blend), sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend), blend < 0.5);\n                }\n\n                fn blendSoftLight(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended: vec3<f32> = vec3<f32>(\n                        softLight(base.r, blend.r),\n                        softLight(base.g, blend.g),\n                        softLight(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendSoftLight(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAgBO,MAAM,uBAAuB,eACpC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,cAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,YAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/SubtractBlend.d.ts

@@ -0,0 +1,18 @@
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';
+import type { ExtensionMetadata } from '../extensions/Extensions';
+/**
+ * Subtracts the blend from the base color using each color channel
+ * Available as `container.blendMode = 'subtract'` after importing `pixi.js/advanced-blend-modes`.
+ * @example
+ * import 'pixi.js/advanced-blend-modes';
+ * import { Sprite } from 'pixi.js';
+ *
+ * const sprite = Sprite.from('something.png');
+ * sprite.blendMode = 'subtract'
+ * @memberof filters
+ */
+export declare class SubtractBlend extends BlendModeFilter {
+    /** @ignore */
+    static extension: ExtensionMetadata;
+    constructor();
+}

node_modules/pixi.js/lib/advanced-blend-modes/SubtractBlend.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Extensions = require('../extensions/Extensions.js');
+var BlendModeFilter = require('../filters/blend-modes/BlendModeFilter.js');
+
+"use strict";
+class SubtractBlend extends BlendModeFilter.BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float subtract(float base, float blend)
+                {
+                    return max(0.0, base - blend);
+                }
+
+                vec3 blendSubtract(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        subtract(base.r, blend.r),
+                        subtract(base.g, blend.g),
+                        subtract(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn subtract(base: f32, blend: f32) -> f32
+                {
+                    return max(0, base - blend);
+                }
+
+                fn blendSubtract(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        subtract(base.r, blend.r),
+                        subtract(base.g, blend.g),
+                        subtract(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+SubtractBlend.extension = {
+  name: "subtract",
+  type: Extensions.ExtensionType.BlendMode
+};
+
+exports.SubtractBlend = SubtractBlend;
+//# sourceMappingURL=SubtractBlend.js.map

node_modules/pixi.js/lib/advanced-blend-modes/SubtractBlend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubtractBlend.js","sources":["../../src/advanced-blend-modes/SubtractBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Subtracts the blend from the base color using each color channel\n * Available as `container.blendMode = 'subtract'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'subtract'\n * @memberof filters\n */\nexport class SubtractBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'subtract',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float subtract(float base, float blend)\n                {\n                    return max(0.0, base - blend);\n                }\n\n                vec3 blendSubtract(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        subtract(base.r, blend.r),\n                        subtract(base.g, blend.g),\n                        subtract(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn subtract(base: f32, blend: f32) -> f32\n                {\n                    return max(0, base - blend);\n                }\n\n                fn blendSubtract(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        subtract(base.r, blend.r),\n                        subtract(base.g, blend.g),\n                        subtract(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":["BlendModeFilter","ExtensionType"],"mappings":";;;;;;AAkBO,MAAM,sBAAsBA,+BACnC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,aAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,UAAA;AAAA,EACN,MAAMC,wBAAc,CAAA,SAAA;AACxB,CAAA;;;;"}

node_modules/pixi.js/lib/advanced-blend-modes/SubtractBlend.mjs

@@ -0,0 +1,62 @@
+import { ExtensionType } from '../extensions/Extensions.mjs';
+import { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter.mjs';
+
+"use strict";
+class SubtractBlend extends BlendModeFilter {
+  constructor() {
+    super({
+      gl: {
+        functions: `
+                float subtract(float base, float blend)
+                {
+                    return max(0.0, base - blend);
+                }
+
+                vec3 blendSubtract(vec3 base, vec3 blend, float opacity)
+                {
+                    vec3 blended = vec3(
+                        subtract(base.r, blend.r),
+                        subtract(base.g, blend.g),
+                        subtract(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                finalColor = vec4(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;
+                `
+      },
+      gpu: {
+        functions: `
+                fn subtract(base: f32, blend: f32) -> f32
+                {
+                    return max(0, base - blend);
+                }
+
+                fn blendSubtract(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>
+                {
+                    let blended = vec3<f32>(
+                        subtract(base.r, blend.r),
+                        subtract(base.g, blend.g),
+                        subtract(base.b, blend.b)
+                    );
+
+                    return (blended * opacity + base * (1.0 - opacity));
+                }
+                `,
+        main: `
+                out = vec4<f32>(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;
+                `
+      }
+    });
+  }
+}
+/** @ignore */
+SubtractBlend.extension = {
+  name: "subtract",
+  type: ExtensionType.BlendMode
+};
+
+export { SubtractBlend };
+//# sourceMappingURL=SubtractBlend.mjs.map

node_modules/pixi.js/lib/advanced-blend-modes/SubtractBlend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubtractBlend.mjs","sources":["../../src/advanced-blend-modes/SubtractBlend.ts"],"sourcesContent":["/* eslint-disable max-len */\n\nimport { ExtensionType } from '../extensions/Extensions';\nimport { BlendModeFilter } from '../filters/blend-modes/BlendModeFilter';\n\nimport type { ExtensionMetadata } from '../extensions/Extensions';\n\n/**\n * Subtracts the blend from the base color using each color channel\n * Available as `container.blendMode = 'subtract'` after importing `pixi.js/advanced-blend-modes`.\n * @example\n * import 'pixi.js/advanced-blend-modes';\n * import { Sprite } from 'pixi.js';\n *\n * const sprite = Sprite.from('something.png');\n * sprite.blendMode = 'subtract'\n * @memberof filters\n */\nexport class SubtractBlend extends BlendModeFilter\n{\n    /** @ignore */\n    public static extension: ExtensionMetadata = {\n        name: 'subtract',\n        type: ExtensionType.BlendMode\n    };\n\n    constructor()\n    {\n        super({\n            gl: {\n                functions: `\n                float subtract(float base, float blend)\n                {\n                    return max(0.0, base - blend);\n                }\n\n                vec3 blendSubtract(vec3 base, vec3 blend, float opacity)\n                {\n                    vec3 blended = vec3(\n                        subtract(base.r, blend.r),\n                        subtract(base.g, blend.g),\n                        subtract(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                finalColor = vec4(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * uBlend;\n                `\n            },\n            gpu: {\n                functions: `\n                fn subtract(base: f32, blend: f32) -> f32\n                {\n                    return max(0, base - blend);\n                }\n\n                fn blendSubtract(base:vec3<f32>,  blend:vec3<f32>,  opacity:f32) -> vec3<f32>\n                {\n                    let blended = vec3<f32>(\n                        subtract(base.r, blend.r),\n                        subtract(base.g, blend.g),\n                        subtract(base.b, blend.b)\n                    );\n\n                    return (blended * opacity + base * (1.0 - opacity));\n                }\n                `,\n                main: `\n                out = vec4<f32>(blendSubtract(back.rgb, front.rgb, front.a), blendedAlpha) * blendUniforms.uBlend;\n                `\n            }\n        });\n    }\n}\n"],"names":[],"mappings":";;;;AAkBO,MAAM,sBAAsB,eACnC,CAAA;AAAA,EAOI,WACA,GAAA;AACI,IAAM,KAAA,CAAA;AAAA,MACF,EAAI,EAAA;AAAA,QACA,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,MACA,GAAK,EAAA;AAAA,QACD,SAAW,EAAA,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,QAiBX,IAAM,EAAA,CAAA;AAAA;AAAA,gBAAA,CAAA;AAAA,OAGV;AAAA,KACH,CAAA,CAAA;AAAA,GACL;AACJ,CAAA;AAAA;AAzDa,aAAA,CAGK,SAA+B,GAAA;AAAA,EACzC,IAAM,EAAA,UAAA;AAAA,EACN,MAAM,aAAc,CAAA,SAAA;AACxB,CAAA;;;;"}