lygia 1.3.0 → 1.3.2

package/README.md

@@ -1,14 +1,14 @@
 <img src="https://lygia.xyz/imgs/lygia.svg" alt="LYGIA" width="200" style="display: block; margin-left: auto; margin-right: auto; filter: drop-shadow(2px 3px 4px gray);">
 
-# LYGIA Shader Library 
+# LYGIA Shader Library
 
-LYGIA is the biggest shader library. Battle proof, cross platform and multi-language. Is made of reusable functions that will let you prototype, port and ship projects in just few minutes. It's very granular, flexible and efficient. Support multiple shading languages and can easily be added to virtually any project. There are already integrations for almost all mayor enviroments, engines and frameworks. 
+LYGIA is the biggest shader library. Battle proof, cross-platform and multi-language. Is made of reusable functions that will let you prototype, port and ship projects in just few minutes. It's very granular, flexible and efficient, supports multiple shading languages and can easily be added to virtually any project. There are already integrations for almost all major environments, engines and frameworks.
 
-Best of all, LYGIA grows and improves every day thanks to the support of the community. Become a [Contributor](https://github.com/patriciogonzalezvivo/lygia) or a [![](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub)](https://github.com/sponsors/patriciogonzalezvivo)
+Best of all, LYGIA grows and improves every day thanks to the support of the community. Become a [Contributor](https://github.com/patriciogonzalezvivo/lygia) or a [![Sponsor](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub)](https://github.com/sponsors/patriciogonzalezvivo).
 
 ## How to use it?
 
-In your shader just `#include` the functions you need and then use them:
+In your shader just `#include` the functions you need and use them:
 
 <div class="codeAndCanvas" data="example.frag">
 
@@ -65,7 +65,7 @@ LYGIA have been integrated into the following Engines, Frameworks, Creative Tool
 <p style="text-align: center;" >
     <a href="https://github.com/patriciogonzalezvivo/lygia_p5_examples"><img src="https://lygia.xyz/imgs/p5.png" alt="p5" title="processing" width="64" /></a>
     <a href="https://editor.p5js.org/patriciogonzalezvivo/sketches"><img src="https://lygia.xyz/imgs/p5js.png" alt="p5js" title="p5js" width="64" /></a>
-    <a href="https://github.com/patriciogonzalezvivo/lygia_of_examples"><img src="https://lygia.xyz/imgs/of.png" alt="openFrameworks" tittle="openframeworks" width="64" /></a>
+    <a href="https://github.com/patriciogonzalezvivo/lygia_of_examples"><img src="https://lygia.xyz/imgs/of.png" alt="openFrameworks" title="openframeworks" width="64" /></a>
     <a href="https://github.com/vectorsize/lygia-td"><img title="static-resolver by vectorsize" src="https://lygia.xyz/imgs/td.png" alt="touchDesigner" title="touchDesigner" width="64" /></a>
     <a href="https://github.com/patriciogonzalezvivo/comfyui_glslnodes"><img src="https://lygia.xyz/imgs/comfy.png" alt="comfyui" title="comfyUI" width="64" /></a>
     <a href="https://github.com/ossia/score-examples"><img src="https://lygia.xyz/imgs/ossia.png" alt="ossia" title="ossia" width="64" /></a>
@@ -80,11 +80,11 @@ LYGIA have been integrated into the following Engines, Frameworks, Creative Tool
     <a href="https://dev.shader.app/"><img src="https://dev.shaders.app/apple-touch-icon.png" alt="shaderApp" title="shaderApp" width="64"/></a>
 </p>
 
-If you are working on a project and want to use LYGIA, you have two options: cloning a **local** version that then you can bundle into your project; or using the **server** ( https://lygia.xyz ) to resolve the dependencies online. How each one works?
+If you are working on a project and want to use LYGIA, you have two options: cloning a **local** version that you can bundle into your project; or using the **server** ( https://lygia.xyz ) to resolve the dependencies online.
 
 ### LYGIA Locally
 
-If you want to work **locally**, you must ensure that your environment can resolve `#include` dependencies. You can find some examples in [here specially for GLSL](https://github.com/patriciogonzalezvivo/lygia/blob/main/README_GLSL.md). Then you just need to clone LYGIA into your project relative to the shader you are loading:
+If you want to work **locally**, you must ensure that your environment can resolve `#include` dependencies. You can find some examples in [here specifically for GLSL](https://github.com/patriciogonzalezvivo/lygia/blob/main/README_GLSL.md). Then you just need to clone LYGIA into your project relative to the shader you are loading:
 
 ```bash
     git clone https://github.com/patriciogonzalezvivo/lygia.git
@@ -108,26 +108,25 @@ If you are concerned about the size of the library you might also be interested
     python prune.py --all --keep glsl
 ```
 
-Alternatively, if your are working on a `npm` project, there is a [npm bundle](https://www.npmjs.com/package/lygia) you could use.
-
-If you are working on web project you may want to resolve the dependencies using a bundler like [vite glsl plugin (local bundle)](https://github.com/UstymUkhman/vite-plugin-glsl), [esbuild glsl plugin (local bundle)](https://github.com/ricardomatias/esbuild-plugin-glsl-include) or [webpack glsl plugin (local bundle)](https://github.com/grieve/webpack-glsl-loader).
+Alternatively, if you are working on a `npm` project, there is a [npm bundle](https://www.npmjs.com/package/lygia) you could use.
 
+If you are working on a web project you may want to resolve the dependencies using a bundler like [vite glsl plugin (local bundle)](https://github.com/UstymUkhman/vite-plugin-glsl), [esbuild glsl plugin (local bundle)](https://github.com/ricardomatias/esbuild-plugin-glsl-include) or [webpack glsl plugin (local bundle)](https://github.com/grieve/webpack-glsl-loader).
 
 ### LYGIA server
 
-If you are working on a **cloud platform** (like [CodePen](https://codepen.io/) or [Observable](https://observablehq.com/@radames/hello-lygia-shader-library) ) you probably want to resolve the dependencies without needing to install anything. For that just add a link to `https://lygia.xyz/resolve.js` (JS) or `https://lygia.xyz/resolve.esm.js` (ES6 module): 
+If you are working on a **cloud platform** (like [CodePen](https://codepen.io/) or [Observable](https://observablehq.com/@radames/hello-lygia-shader-library)) you probably want to resolve the dependencies without needing to install anything. For that just add a link to `https://lygia.xyz/resolve.js` (JS) or `https://lygia.xyz/resolve.esm.js` (ES6 module):
 
 ```html
-    <!-- as a JavaScript source -->
+    <!-- As JavaScript source -->
     <script src="https://lygia.xyz/resolve.js"></script>
 
-    <!-- Or as a ES6 module -->
+    <!-- Or as an ES6 module -->
     <script type="module">
         import resolveLygia from "https://lygia.xyz/resolve.esm.js"
     </script>
 ```
 
-To then resolve the dependencies by passing a `string` or `strings[]` to `resolveLygia()` or `resolveLygiaAsync()`:
+Then you can resolve the dependencies by passing a `string` or `strings[]` to `resolveLygia()` or `resolveLygiaAsync()`:
 
 ```js
     // 1. FIRST
@@ -138,7 +137,7 @@ To then resolve the dependencies by passing a `string` or `strings[]` to `resolv
 
     // OR.
     
-    // ASync resolver, all includes in parallel calls
+    // Async resolver, all includes in parallel calls
     vertSource = resolveLygiaAsync(vertSource);
     fragSource = resolveLygiaAsync(fragSource);
     
@@ -165,19 +164,18 @@ The functions are divided into different categories:
 * [`animation/`](https://lygia.xyz/animation): animation operations: easing
 * [`generative/`](https://lygia.xyz/generative): generative functions: `random()`, `noise()`, etc. 
 * [`sdf/`](https://lygia.xyz/sdf): signed distance field functions.
-* [`draw/`](https://lygia.xyz/draw): drawing functions like `digits()`, `stroke()`, `fill`, etc/.
+* [`draw/`](https://lygia.xyz/draw): drawing functions like `digits()`, `stroke()`, `fill`, etc.
 * [`sample/`](https://lygia.xyz/sample): sample operations
 * [`filter/`](https://lygia.xyz/filter): typical filter operations: different kind of blurs, mean and median filters.
 * [`distort/`](https://lygia.xyz/distort): distort sampling operations
-* [`lighting/`](https://lygia.xyz/lighting): different lighting models and functions for foward/deferred/raymarching rendering
+* [`lighting/`](https://lygia.xyz/lighting): different lighting models and functions for forward/deferred/raymarching rendering
 * [`geometry/`](https://lygia.xyz/geometry): operation related to geometries: intersections and AABB accelerating structures.
 * [`morphological/`](https://lygia.xyz/morphological): morphological filters: dilation, erosion, alpha and poisson fill.
 
-
 ### How is it [designed](https://github.com/patriciogonzalezvivo/lygia/blob/main/DESIGN.md)?
 
-LYGIA is designed to be very granular (each file holds one function), multilanguage (each language have it's onw file extension) and flexible. Flexible how?
-There are some functions whose behavior can be changed using the `#defines` keyword before including it. For example, [gaussian blurs](filter/gaussianBlur.glsl) are usually are done in two passes. By default, these are performed on their 1D version, but if you are interested in using a 2D kernel, all in the same pass, you will need to add the `GAUSSIANBLUR_2D` keyword this way:
+LYGIA is designed to be very granular (each file holds one function), multi-language (each language has its own file extension) and flexible. Flexible how?
+There are some functions whose behavior can be changed using the `#define` keyword before including them. For example, [gaussian blurs](filter/gaussianBlur) are usually done in two passes. By default, these are performed on their 1D version, but if you are interested in using a 2D kernel, all in the same pass, you will need to add the `GAUSSIANBLUR_2D` keyword, as follows:
 
 ```glsl
 
@@ -204,38 +202,35 @@ In the same way you can change the sampling function that the gaussian uses. Ex:
 #define GAUSSIANBLUR_SAMPLER_FNC(TEX, UV) sampleClamp2edge(TEX, UV)
 ```
 
-Learn more about [LYGIAS design principles in the DESIGN.md file](https://github.com/patriciogonzalezvivo/lygia/blob/main/DESIGN.md).
+Learn more about [LYGIA's design principles in the DESIGN.md file](https://github.com/patriciogonzalezvivo/lygia/blob/main/DESIGN.md).
 
 ## Contributions
 
 LYGIA has a long way to go and welcomes all kinds of contributions. You can help by:
 
 * **Bug fixing**
-* **Translation**, keeping parity between languages (GLSL, HLSL, MSL, WGSL, TSL, CUDA, OSL, etc) is a big part of the challenge. Not all language are the same and we want to make sure make sure each function is optimized and carefully crafted for each enviroment. This means, the more eyes looking at this, the better. Please make sure to read and understand the [Design Principles](https://github.com/patriciogonzalezvivo/lygia/blob/main/DESIGN.md) before starting.
-* **New functions or improving the current implementations**. Please take a look to the [Contributing Guidelines](https://github.com/patriciogonzalezvivo/lygia/blob/main/CONTRIBUTING.md) before starting.
+* **Translation**, keeping parity between languages (GLSL, HLSL, MSL, WGSL, TSL, CUDA, OSL, etc.) is a big part of the challenge. Not all languages are the same and we want to make sure each function is optimized and carefully crafted for each environment. This means, the more eyes are looking at this, the better. Please make sure to read and understand the [Design Principles](https://github.com/patriciogonzalezvivo/lygia/blob/main/DESIGN.md) before starting.
+* **New functions or improving the current implementations**. Please take a look to the [Contribution Guidelines](https://github.com/patriciogonzalezvivo/lygia/blob/main/CONTRIBUTE.md) before starting.
 * **Documentation**. Each function has a header with some information describing the function. Make sure to fill this information when adding a new function.
 * Adding new **examples** and integrations for new environments like: [Godot](https://godotengine.org/), [ISF](https://isf.video/), [MaxMSP](https://cycling74.com/products/max), etc.
-* **Financial** [sponsorships](https://github.com/sponsors/patriciogonzalezvivo). Right now, the money that flows in is invested on the server and infraestructure. Long term plan will be to be able to pay lead contributors and mantainers.
+* **Financial** [sponsorships](https://github.com/sponsors/patriciogonzalezvivo). Right now, the money that flows in is invested on the server and infrastructure. Long term plan will be to be able to pay lead contributors and maintainers.
 
-Collaborators and sponsors are automatically added to the [commercial license](https://lygia.xyz/license). Making a PR or subscribing to the github sponsors program is the shortest path to get access to the commercial license. It's all automated, not red taping. LYGIA belongs to those that takes care of it.
+Collaborators and sponsors are automatically added to the [commercial license](https://lygia.xyz/license). Making a PR or subscribing to the GitHub sponsors program is the shortest path to get access to the commercial license. It's all automated, not red taping. LYGIA belongs to those that take care of it.
 
-## License 
+## License
 
-LYGIA belongs to those that support it. For that it uses a dual-licensed under the [Prosperity License](https://prosperitylicense.com/versions/3.0.0) and the [Patron License](https://lygia.xyz/license) for [sponsors](https://github.com/sponsors/patriciogonzalezvivo) and [contributors](https://github.com/patriciogonzalezvivo/lygia/graphs/contributors).
+LYGIA belongs to those that support it. For that it is dual-licensed under the [Prosperity License](https://prosperitylicense.com/versions/3.0.0) and the [Patron License](https://lygia.xyz/license) for [sponsors](https://github.com/sponsors/patriciogonzalezvivo) and [contributors](https://github.com/patriciogonzalezvivo/lygia/graphs/contributors).
 
 [Sponsors](https://github.com/sponsors/patriciogonzalezvivo) and [contributors](https://github.com/patriciogonzalezvivo/lygia/graphs/contributors) are automatically added to the [Patron License](https://lygia.xyz/license) and they can ignore any non-commercial rule of the [Prosperity License](https://prosperitylicense.com/versions/3.0.0) software.
 
 It's also possible to get a permanent commercial license hooked to a single and specific version of LYGIA.
 
-If you have doubts please reaching out to patriciogonzalezvivo at gmail dot com
+If you have doubts please reach out to patriciogonzalezvivo at gmail dot com
 
 ## Credits
 
-Created and mantained by [Patricio Gonzalez Vivo](https://patriciogonzalezvivo.com/)( <a rel="me" href="https://merveilles.town/@patricio">Mastodon</a> | [Twitter](https://twitter.com/patriciogv) | [Instagram](https://www.instagram.com/patriciogonzalezvivo/) | [GitHub](https://github.com/sponsors/patriciogonzalezvivo) ) and every direct or indirect [contributors](https://github.com/patriciogonzalezvivo/lygia/graphs/contributors) to the GitHub. 
+Created and maintained by [Patricio Gonzalez Vivo](https://patriciogonzalezvivo.com/) ( <a rel="me" href="https://merveilles.town/@patricio">Mastodon</a> | [Twitter](https://twitter.com/patriciogv) | [Instagram](https://www.instagram.com/patriciogonzalezvivo/) | [GitHub](https://github.com/sponsors/patriciogonzalezvivo) ) and every direct or indirect [contributors](https://github.com/patriciogonzalezvivo/lygia/graphs/contributors) to the GitHub repository.
 
 This library has been built in many cases on top of the work of brilliant and generous people like: [Inigo Quiles](https://www.iquilezles.org/), [Morgan McGuire](https://casual-effects.com/), [Alan Wolfe](https://blog.demofox.org/), [Matt DesLauriers](https://www.mattdesl.com/), [Bjorn Ottosson](https://github.com/bottosson), [Hugh Kennedy](https://github.com/hughsk), and many others.
 
-Also is being constantly mantain, translated and/or extended by generous contributors like: [Shadi El Hajj](https://github.com/shadielhajj), [Kathy](https://github.com/kfahn22), [Bonsak Schiledrop](https://github.com/bonsak), [Amin Shazrin](https://github.com/ammein), [Guido Schmidt](https://github.com/guidoschmidt), and many others.
-
-
-
+It also is being constantly maintained, translated and/or extended by generous contributors like: [Shadi El Hajj](https://github.com/shadielhajj), [Kathy](https://github.com/kfahn22), [Bonsak Schiledrop](https://github.com/bonsak), [Amin Shazrin](https://github.com/ammein), [Guido Schmidt](https://github.com/guidoschmidt), and many others.

package/dist/color/blend/add/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/add.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Add blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendAdd(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendAdd(base : f32, blend : f32) -> f32 { return min(base + blend, 1.0); }\nfn blendAdd3(base : vec3f, blend : vec3f) -> vec3f { return min(base + blend, vec3(1.0)); }\nfn blendAdd3Opacity(base : vec3f, blend : vec3f, opacity : f32) -> vec3f { return blendAdd3(base, blend) * opacity + base * (1.0 - opacity); }\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/average/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/average.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Average blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendAverage(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendAverage(base : f32, blend : f32) -> f32 { return (base + blend) * 0.5; }\nfn blendAverage3(base : vec3f, blend : vec3f) -> vec3f { return (base + blend) * 0.5; }\nfn blendAverage3Opacity(base : vec3f, blend : vec3f, opacity : f32) -> vec3f { return (blendAverage3(base, blend) * opacity + base * (1.0 - opacity)); }\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/color/weslBundle.js

@@ -0,0 +1,14 @@
+import lygia_color_space_rgb2hsv from "lygia/color/space/rgb2hsv";
+import lygia_color_space_hsv2rgb from "lygia/color/space/hsv2rgb";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/color.wesl":
+      "import lygia::color::space::{rgb2hsv::rgb2hsv, hsv2rgb::hsv2rgb};\n\n/*\ncontributors: Romain Dura\ndescription: Color Blend mode creates the result color by combining the luminance of the base color with the hue and saturation of the blend color.\nuse: blendColor(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendColor(base: vec3f, blend: vec3f) -> vec3f {\n  let baseHSL = rgb2hsv(base);\n  let blendHSL = rgb2hsv(blend);\n\n  return hsv2rgb(vec3f(blendHSL.x, blendHSL.y, baseHSL.z));\n}\n\nfn blendColorOpacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendColor(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_space_rgb2hsv, lygia_color_space_hsv2rgb],
+};
+
+export default weslBundle;

package/dist/color/blend/colorBurn/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/colorBurn.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Color Burn blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendColorBurn(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendColorBurn(base: f32, blend: f32) -> f32 {\n  return select(max((1.0 - ((1.0 - base) / blend)), 0.0), blend, blend == 0.0);\n}\n\nfn blendColorBurn3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendColorBurn(base.r, blend.r),\n    blendColorBurn(base.g, blend.g),\n    blendColorBurn(base.b, blend.b)\n  );\n}\n\nfn blendColorBurn3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendColorBurn3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/colorDodge/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/colorDodge.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Color Dodge blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendColorDodge(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendColorDodge(base: f32, blend: f32) -> f32 {\n  return select(min(base / (1.0 - blend), 1.0), blend, blend == 1.0);\n}\n\nfn blendColorDodge3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendColorDodge(base.r, blend.r),\n    blendColorDodge(base.g, blend.g),\n    blendColorDodge(base.b, blend.b)\n  );\n}\n\nfn blendColorDodge3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendColorDodge3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/darken/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/darken.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Darken blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendDarken(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendDarken(base: f32, blend: f32) -> f32 {\n  return min(blend, base);\n}\n\nfn blendDarken3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendDarken(base.r, blend.r),\n    blendDarken(base.g, blend.g),\n    blendDarken(base.b, blend.b)\n  );\n}\n\nfn blendDarken3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendDarken3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/difference/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/difference.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Difference blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendDifference(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendDifference(base: f32, blend: f32) -> f32 {\n  return abs(base - blend);\n}\n\nfn blendDifference3(base: vec3f, blend: vec3f) -> vec3f {\n  return abs(base - blend);\n}\n\nfn blendDifference3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendDifference3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/exclusion/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/exclusion.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Exclusion blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendExclusion(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendExclusion(base: f32, blend: f32) -> f32 {\n  return base + blend - 2.0 * base * blend;\n}\n\nfn blendExclusion3(base: vec3f, blend: vec3f) -> vec3f {\n  return base + blend - 2.0 * base * blend;\n}\n\nfn blendExclusion3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendExclusion3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/glow/weslBundle.js

@@ -0,0 +1,13 @@
+import lygia_color_blend_reflect from "lygia/color/blend/reflect";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/glow.wesl":
+      "import lygia::color::blend::reflect::{blendReflect, blendReflect3};\n\n/*\ncontributors: Jamie Owen\ndescription: Photoshop Glow blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendGlow(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendGlow(base: f32, blend: f32) -> f32 {\n  return blendReflect(blend, base);\n}\n\nfn blendGlow3(base: vec3f, blend: vec3f) -> vec3f {\n  return blendReflect3(blend, base);\n}\n\nfn blendGlow3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendGlow3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_blend_reflect],
+};
+
+export default weslBundle;

package/dist/color/blend/hardLight/weslBundle.js

@@ -0,0 +1,13 @@
+import lygia_color_blend_overlay from "lygia/color/blend/overlay";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/hardLight.wesl":
+      "import lygia::color::blend::overlay::blendOverlay;\n\n/*\ncontributors: Jamie Owen\ndescription: Photoshop HardLight blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendHardLight(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendHardLight(base: f32, blend: f32) -> f32 {\n  return blendOverlay(blend, base);\n}\n\nfn blendHardLight3(base: vec3f, blend: vec3f) -> vec3f {\n  return blendOverlay(blend, base);\n}\n\nfn blendHardLight3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendHardLight3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_blend_overlay],
+};
+
+export default weslBundle;

package/dist/color/blend/hardMix/weslBundle.js

@@ -0,0 +1,13 @@
+import lygia_color_blend_vividLight from "lygia/color/blend/vividLight";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/hardMix.wesl":
+      "import lygia::color::blend::vividLight::blendVividLight;\n\n/*\ncontributors: Jamie Owen\ndescription: Photoshop Hard Mix blend mode implementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendHardMix(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendHardMix(base: f32, blend: f32) -> f32 {\n  return select(1.0, 0.0, blendVividLight(base, blend) < 0.5);\n}\n\nfn blendHardMix3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendHardMix(base.r, blend.r),\n    blendHardMix(base.g, blend.g),\n    blendHardMix(base.b, blend.b)\n  );\n}\n\nfn blendHardMix3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendHardMix3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_blend_vividLight],
+};
+
+export default weslBundle;

package/dist/color/blend/hue/weslBundle.js

@@ -0,0 +1,14 @@
+import lygia_color_space_rgb2hsv from "lygia/color/space/rgb2hsv";
+import lygia_color_space_hsv2rgb from "lygia/color/space/hsv2rgb";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/hue.wesl":
+      "import lygia::color::space::{rgb2hsv::rgb2hsv, hsv2rgb::hsv2rgb};\n\n/*\ncontributors: Romain Dura\ndescription: Hue Blend mode creates the result color by combining the luminance and saturation of the base color with the hue of the blend color.\nuse: blendHue(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendHue(base: vec3f, blend: vec3f) -> vec3f {\n  let baseHSV = rgb2hsv(base);\n  let blendHSV = rgb2hsv(blend);\n  return hsv2rgb(vec3f(blendHSV.x, baseHSV.y, baseHSV.z));\n}\n\nfn blendHueOpacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendHue(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_space_rgb2hsv, lygia_color_space_hsv2rgb],
+};
+
+export default weslBundle;

package/dist/color/blend/lighten/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/lighten.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Lighten blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendLighten(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendLighten(base: f32, blend: f32) -> f32 {\n  return max(blend, base);\n}\n\nfn blendLighten3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendLighten(base.r, blend.r),\n    blendLighten(base.g, blend.g),\n    blendLighten(base.b, blend.b)\n  );\n}\n\nfn blendLighten3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendLighten3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/linearBurn/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/linearBurn.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Linear Burn blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendLinearBurn(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendLinearBurn(base: f32, blend: f32) -> f32 {\n  // Note: Same implementation as BlendSubtractf\n  return max(base + blend - 1.0, 0.0);\n}\n\nfn blendLinearBurn3(base: vec3f, blend: vec3f) -> vec3f {\n  // Note: Same implementation as BlendSubtract\n  return max(base + blend - vec3f(1.0), vec3f(0.0));\n}\n\nfn blendLinearBurn3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendLinearBurn3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/linearDodge/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/linearDodge.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Linear Dodge blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendLinearDodge(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendLinearDodge(base: f32, blend: f32) -> f32 {\n  // Note: Same implementation as BlendAddf\n  return min(base + blend, 1.0);\n}\n\nfn blendLinearDodge3(base: vec3f, blend: vec3f) -> vec3f {\n  // Note: Same implementation as BlendAdd\n  return min(base + blend, vec3f(1.0));\n}\n\nfn blendLinearDodge3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendLinearDodge3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/linearLight/weslBundle.js

@@ -0,0 +1,14 @@
+import lygia_color_blend_linearDodge from "lygia/color/blend/linearDodge";
+import lygia_color_blend_linearBurn from "lygia/color/blend/linearBurn";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/linearLight.wesl":
+      "import lygia::color::blend::linearDodge::blendLinearDodge;\nimport lygia::color::blend::linearBurn::blendLinearBurn;\n\n/*\ncontributors: Jamie Owen\ndescription: Photoshop Linear Light blend mode implementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendLinearLight(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendLinearLight(base: f32, blend: f32) -> f32 {\n  return select(blendLinearDodge(base, (blend - 0.5) * 2.0), blendLinearBurn(base, blend * 2.0), blend < 0.5);\n}\n\nfn blendLinearLight3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendLinearLight(base.r, blend.r),\n    blendLinearLight(base.g, blend.g),\n    blendLinearLight(base.b, blend.b)\n  );\n}\n\nfn blendLinearLight3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendLinearLight3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_blend_linearDodge, lygia_color_blend_linearBurn],
+};
+
+export default weslBundle;

package/dist/color/blend/luminosity/weslBundle.js

@@ -0,0 +1,14 @@
+import lygia_color_space_rgb2hsv from "lygia/color/space/rgb2hsv";
+import lygia_color_space_hsv2rgb from "lygia/color/space/hsv2rgb";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/luminosity.wesl":
+      "import lygia::color::space::{rgb2hsv::rgb2hsv, hsv2rgb::hsv2rgb};\n\n/*\ncontributors: Romain Dura\ndescription: Luminosity Blend mode creates the result color by combining the hue and luminance of the base color with the saturation of the blend color.\nuse: blendLuminosity(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendLuminosity(base: vec3f, blend: vec3f) -> vec3f {\n  let baseHSL = rgb2hsv(base);\n  let blendHSL = rgb2hsv(blend);\n  return hsv2rgb(vec3f(baseHSL.x, baseHSL.y, blendHSL.z));\n}\n\nfn blendLuminosityOpacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendLuminosity(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_space_rgb2hsv, lygia_color_space_hsv2rgb],
+};
+
+export default weslBundle;

package/dist/color/blend/multiply/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/multiply.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Multiply blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendMultiply(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendMultiply(base: f32, blend: f32) -> f32 {\n    return base * blend;\n}\n\nfn blendMultiply3(base: vec3f, blend: vec3f) -> vec3f {\n    return base * blend;\n}\n\nfn blendMultiply3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n    return (blendMultiply3(base, blend) * opacity + base * (1. - opacity));\n}",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/negation/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/negation.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Negation blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendNegation(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendNegation(base: f32, blend: f32) -> f32 {\n  return 1.0 - abs(1.0 - base - blend);\n}\n\nfn blendNegation3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(1.0) - abs(vec3f(1.0) - base - blend);\n}\n\nfn blendNegation3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendNegation3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/overlay/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/overlay.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Overlay blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendOverlay(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendOverlay(base: f32, blend: f32) -> f32 {\n    if (base < 0.5) {\n        return (2.*base*blend);\n    } else {\n        return (1. - 2. * (1. - base) * (1. - blend));\n    }\n}\n\nfn blendOverlay3(base: vec3f, blend: vec3f) -> vec3f {\n    return vec3(blendOverlay(base.r, blend.r),\n                blendOverlay(base.g, blend.g),\n                blendOverlay(base.b, blend.b));\n}\n\nfn blendOverlay3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n    return (blendOverlay3(base, blend) * opacity + base * (1. - opacity));\n}",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/phoenix/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/phoenix.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Phoenix blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendPhoenix(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendPhoenix(base: f32, blend: f32) -> f32 {\n  return min(base, blend) - max(base, blend) + 1.0;\n}\n\nfn blendPhoenix3(base: vec3f, blend: vec3f) -> vec3f {\n  return min(base, blend) - max(base, blend) + vec3f(1.0);\n}\n\nfn blendPhoenix3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendPhoenix3(base, blend) * opacity + base * (1.0 - opacity);\n}",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/pinLight/weslBundle.js

@@ -0,0 +1,14 @@
+import lygia_color_blend_lighten from "lygia/color/blend/lighten";
+import lygia_color_blend_darken from "lygia/color/blend/darken";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/pinLight.wesl":
+      "import lygia::color::blend::lighten::blendLighten;\nimport lygia::color::blend::darken::blendDarken;\n\n/*\ncontributors: Jamie Owen\ndescription: Photoshop Pin Light blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendPinLight(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendPinLight(base: f32, blend: f32) -> f32 {\n  return select(blendLighten(base, (blend - 0.5) * 2.0), blendDarken(base, blend * 2.0), blend < 0.5);\n}\n\nfn blendPinLight3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendPinLight(base.r, blend.r),\n    blendPinLight(base.g, blend.g),\n    blendPinLight(base.b, blend.b)\n  );\n}\n\nfn blendPinLight3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendPinLight3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_blend_lighten, lygia_color_blend_darken],
+};
+
+export default weslBundle;

package/dist/color/blend/reflect/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/reflect.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Reflect blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendReflect(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendReflect(base: f32, blend: f32) -> f32 {\n  return select(min(base * base / (1.0 - blend), 1.0), blend, blend == 1.0);\n}\n\nfn blendReflect3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendReflect(base.r, blend.r),\n    blendReflect(base.g, blend.g),\n    blendReflect(base.b, blend.b)\n  );\n}\n\nfn blendReflect3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendReflect3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/saturation/weslBundle.js

@@ -0,0 +1,14 @@
+import lygia_color_space_rgb2hsv from "lygia/color/space/rgb2hsv";
+import lygia_color_space_hsv2rgb from "lygia/color/space/hsv2rgb";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/saturation.wesl":
+      "import lygia::color::space::{rgb2hsv::rgb2hsv, hsv2rgb::hsv2rgb};\n\n/*\ncontributors: Romain Dura\ndescription: Saturation Blend mode creates the result color by combining the hue and luminance of the base color with the saturation of the blend color.\nuse: blendSaturation(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendSaturation(base: vec3f, blend: vec3f) -> vec3f {\n  let baseHSL = rgb2hsv(base);\n  let blendHSL = rgb2hsv(blend);\n  return hsv2rgb(vec3f(baseHSL.x, blendHSL.y, baseHSL.z));\n}\n\nfn blendSaturationOpacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendSaturation(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_space_rgb2hsv, lygia_color_space_hsv2rgb],
+};
+
+export default weslBundle;

package/dist/color/blend/screen/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/screen.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Screen blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendScreen(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendScreen(base: f32, blend: f32) -> f32 {\n    return 1. - ((1. - base) * (1. - blend));\n}\n\nfn blendScreen3(base: vec3f, blend: vec3f) -> vec3f {\n    return vec3f(blendScreen(base.r, blend.r),\n                blendScreen(base.g, blend.g),\n                blendScreen(base.b, blend.b));\n}\n\nfn blendScreenWithOpacity3(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n    return (blendScreen3(base, blend) * opacity + base * (1. - opacity));\n}",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/softLight/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/softLight.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Soft Light blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendSoftLight(<float|vec3> base, <float|vec3> blend [, <float> opacity])\n*/\n\nfn blendSoftLight(base: f32, blend: f32) -> f32 {\n    if (blend < 0.5) {\n        return (2. * base * blend + base * base * (1. - 2.*blend));\n    } else {\n        return (sqrt(base) * (2. * blend - 1.) + 2. * base * (1. - blend));\n    }\n}\n\nfn blendSoftLight3(base: vec3f, blend: vec3f) -> vec3f {\n    return vec3(blendSoftLight(base.r, blend.r),\n                blendSoftLight(base.g, blend.g),\n                blendSoftLight(base.b, blend.b));\n}\n\nfn blendSoftLight4(base: vec4f, blend: vec4f) -> vec4f {\n    return vec4(blendSoftLight( base.r, blend.r ),\n                blendSoftLight( base.g, blend.g ),\n                blendSoftLight( base.b, blend.b ),\n                blendSoftLight( base.a, blend.a )\n    );\n}\n\nfn blendSoftLight3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n    return (blendSoftLight3(base, blend) * opacity + base * (1. - opacity));\n}",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/subtract/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/subtract.wesl":
+      "/*\ncontributors: Jamie Owen\ndescription: Photoshop Soft Light blend mode mplementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendSubtract(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendSubtract(base: f32, blend: f32) -> f32 {\n  return max(base + blend - 1.0, 0.0);\n}\n\nfn blendSubtract3(base: vec3f, blend: vec3f) -> vec3f {\n  return max(base + blend - vec3f(1.0), vec3f(0.0));\n}\n\nfn blendSubtract3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendSubtract3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+};
+
+export default weslBundle;

package/dist/color/blend/vividLight/weslBundle.js

@@ -0,0 +1,14 @@
+import lygia_color_blend_colorDodge from "lygia/color/blend/colorDodge";
+import lygia_color_blend_colorBurn from "lygia/color/blend/colorBurn";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/blend/vividLight.wesl":
+      "import lygia::color::blend::colorBurn::blendColorBurn;\nimport lygia::color::blend::colorDodge::blendColorDodge;\n\n/*\ncontributors: Jamie Owen\ndescription: Photoshop Vivid Light blend mode implementations sourced from this article on https://mouaif.wordpress.com/2009/01/05/photoshop-math-with-glsl-shaders/\nuse: blendVividLight(<float|vec3> base, <float|vec3> blend [, <float> opacity])\nlicense: MIT License (MIT) Copyright (c) 2015 Jamie Owen\n*/\n\nfn blendVividLight(base: f32, blend: f32) -> f32 {\n  return select(blendColorDodge(base, (blend - 0.5) * 2.0), blendColorBurn(base, blend * 2.0), blend < 0.5);\n}\n\nfn blendVividLight3(base: vec3f, blend: vec3f) -> vec3f {\n  return vec3f(\n    blendVividLight(base.r, blend.r),\n    blendVividLight(base.g, blend.g),\n    blendVividLight(base.b, blend.b)\n  );\n}\n\nfn blendVividLight3Opacity(base: vec3f, blend: vec3f, opacity: f32) -> vec3f {\n  return blendVividLight3(base, blend) * opacity + base * (1.0 - opacity);\n}\n",
+  },
+  dependencies: [lygia_color_blend_colorDodge, lygia_color_blend_colorBurn],
+};
+
+export default weslBundle;

package/dist/color/brightnessContrast/weslBundle.js

@@ -0,0 +1,10 @@
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/brightnessContrast.wesl":
+      "/*\ncontributors: Patricio Gonzalez Vivo\ndescription: Modify brightness and contrast\nuse: brightnessContrast(<float|vec3|vec4> color, <float> brightness, <float> amcontrastount)\nexamples:\n    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/color_brightnessContrast.frag\nlicense:\n    - Copyright (c) 2021 Patricio Gonzalez Vivo under Prosperity License - https://prosperitylicense.com/versions/3.0.0\n    - Copyright (c) 2021 Patricio Gonzalez Vivo under Patron License - https://lygia.xyz/license\n*/\n\nfn brightnessContrast(v : f32, b : f32, c : f32) -> f32 { return (v - 0.5) * c + 0.5 + b; }\n\nfn brightnessContrast3(v : vec3f, b : f32, c : f32) -> vec3f { return (v - 0.5) * c + 0.5 + b; }\n\nfn brightnessContrast4(v : vec4f, b : f32, c : f32) -> vec4f { return vec4((v.rgb - 0.5) * c + 0.5 + b, v.a); }",
+  },
+};
+
+export default weslBundle;

package/dist/color/distance/weslBundle.js

@@ -0,0 +1,23 @@
+import lygia_color_space_rgb2lab from "lygia/color/space/rgb2lab";
+import lygia_color_space_rgb2YCbCr from "lygia/color/space/rgb2YCbCr";
+import lygia_color_space_rgb2YPbPr from "lygia/color/space/rgb2YPbPr";
+import lygia_color_space_rgb2yuv from "lygia/color/space/rgb2yuv";
+import lygia_color_space_rgb2oklab from "lygia/color/space/rgb2oklab";
+
+export const weslBundle = {
+  name: "lygia",
+  edition: "unstable_2025_1",
+  modules: {
+    "color/distance.wesl":
+      "import lygia::color::space::{\n    rgb2lab::rgb2lab, \n    rgb2YCbCr::rgb2YCbCr, \n    rgb2YPbPr::rgb2YPbPr, \n    rgb2yuv::rgb2yuv, \n    rgb2oklab::rgb2oklab};\n\n/*\ncontributors: Patricio Gonzalez Vivo\ndescription: Perceptual distance between two color according to CIE94 https://en.wikipedia.org/wiki/Color_difference#CIE94\nuse: colorDistance(<vec3|vec4> rgbA, <vec3|vec4> rgbA)\noptions:\n    - COLORDISTANCE_FNC: |\n        colorDistanceLABCIE94, colorDistanceLAB, colorDistanceYCbCr,\n        colorDistanceYPbPr, colorDistanceYUV, colorDistanceOKLAB\nlicense:\n    - Copyright (c) 2021 Patricio Gonzalez Vivo under Prosperity License - https://prosperitylicense.com/versions/3.0.0\n    - Copyright (c) 2021 Patricio Gonzalez Vivo under Patron License - https://lygia.xyz/license\n*/\n\nfn colorDistanceLABCIE94(rgb1 : vec3<f32>, rgb2 : vec3<f32>) -> f32 {\n    let lab1 = rgb2lab(rgb1);\n    let lab2 = rgb2lab(rgb2);\n\n    let delta = lab1 - lab2;\n    let c1 = sqrt(lab1.y * lab1.y + lab1.z * lab1.z);\n    let c2 = sqrt(lab2.y * lab2.y + lab2.z * lab2.z);\n    let delta_c = c1 - c2;\n    var delta_h = delta.x * delta.x + delta.z * delta.z - delta_c * delta_c;\n    delta_h = mix(0., sqrt(delta_h), step(0., delta_h));\n\n    let sc = 1. + .045 * c1;\n    let sh = 1. + .015 * c1;\n\n    let delta_ckcsc = delta_c / sc;\n    let delta_hkhsh = delta_h / sh;\n\n    let delta_e = delta.x * delta.x + delta_ckcsc * delta_ckcsc + delta_hkhsh * delta_hkhsh;\n    return mix(0., sqrt(delta_e), step(0., delta_e));\n}\n\nfn colorDistanceLAB(rgb1 : vec3<f32>, rgb2 : vec3<f32>) -> f32 {\n    return distance(rgb2lab(rgb1), rgb2lab(rgb2));\n}\nfn colorDistanceYCbCr(rgb1 : vec3<f32>, rgb2 : vec3<f32>) -> f32 {\n    return distance(rgb2YCbCr(rgb1).yz, rgb2YCbCr(rgb2).yz);\n}\nfn colorDistanceYPbPr(rgb1 : vec3<f32>, rgb2 : vec3<f32>) -> f32 {\n    return distance(rgb2YPbPr(rgb1).yz, rgb2YPbPr(rgb2).yz);\n}\nfn colorDistanceYUV(rgb1 : vec3<f32>, rgb2 : vec3<f32>) -> f32 {\n    return distance(rgb2yuv(rgb1), rgb2yuv(rgb2));\n}\nfn colorDistanceOKLAB(rgb1 : vec3<f32>, rgb2 : vec3<f32>) -> f32 {\n    return distance(rgb2oklab(rgb1), rgb2oklab(rgb2));\n}\n",
+  },
+  dependencies: [
+    lygia_color_space_rgb2lab,
+    lygia_color_space_rgb2YCbCr,
+    lygia_color_space_rgb2YPbPr,
+    lygia_color_space_rgb2yuv,
+    lygia_color_space_rgb2oklab,
+  ],
+};
+
+export default weslBundle;