fix: 🐛 category for settings

fix: 🐛 new UI issues
- Fixes the "edit icon cannot be clicked" - Changed the parser to add support for more non std markdown - Markdown links now always open a new tab instead of replacing current - New optional shiki support for code blocks (check #211 for details)
2024-11-20 21:35:07 +01:00 · 2024-11-18 01:53:04 +01:00 · 2024-11-18 01:32:29 +01:00 · 2024-11-18 00:48:04 +01:00 · 2024-11-18 00:45:53 +01:00 · 2024-10-10 02:13:13 +02:00
161 changed files with 9399 additions and 2815 deletions
@@ -0,0 +1,2 @@
+[*]
+end_of_line = lf
@@ -1,10 +1,10 @@
 name: 🐞 Bug Report
-title: "[bug] "
+title: '[bug] '
 description: Report a bug
-labels: ["type: 🐛 bug", "status: 🧹 needs triage"]
+labels: ['type: 🐛 bug', 'status: 🧹 needs triage']
 assignees:
  - melMass
-  
+
 body:
  - type: markdown
    attributes:
@@ -12,6 +12,8 @@ body:
        ## Before submiting an issue
        - Make sure to read the README & INSTALL instructions.  
        - Please search for [existing issues](https://github.com/melMass/comfy_mtb/issues?q=is%3Aissue) around your problem before filing a report.
+        - Optionally check the `#mtb-nodes` channel on the Banodoco discord:  
+          [![](https://dcbadge.vercel.app/api/server/AXhsabmDhn?style=flat)](https://discord.gg/IAXhsabmDhn)

        ### Try using the debug mode to get more info

@@ -54,7 +56,7 @@ body:
      default: 0
    validations:
      required: true
-      
+
  - type: dropdown
    id: comfy_mode
    attributes:
@@ -0,0 +1,18 @@
+name: 📦 Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: ♻️ Check out code
+        uses: actions/checkout@v4
+      - name: 📦 Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          personal_access_token: ${{ secrets.COMFY_REGISTRY_TOKEN }}
@@ -7,3 +7,6 @@
 [submodule "extern/frame_interpolation"]
 	path = extern/frame_interpolation
 	url = https://github.com/google-research/frame-interpolation
+[submodule "wiki"]
+	path = wiki
+	url = https://github.com/melMass/comfy_mtb.wiki.git
@@ -0,0 +1,10 @@
+-- HACK: this should theorically not be needed since the lsp should read from the pyproject
+-- tried: ruff-lsp or basedpyright
+
+local comfyRoot = vim.fn.expand("%:p:h:h:h")
+
+if not vim.env.PYTHONPATH or vim.env.PYTHONPATH == "" then
+	vim.env.PYTHONPATH = comfyRoot
+else
+	vim.env.PYTHONPATH = vim.env.PYTHONPATH .. ";" .. comfyRoot
+end
@@ -0,0 +1,8 @@
+default_language_version:
+  python: python3.10
+repos:
+  - repo: https://github.com/melmass/hooks
+    rev: e8c6c18175ed4f6e30f23991de7989411e09c73b
+    hooks:
+      - id: fix-trailing-whitespace
+      - id: bump-version
@@ -1,93 +0,0 @@
-# 安装
- [安装](#安装)
-    - [自动安装（推荐）](#自动安装推荐)
-    - [ComfyUI 管理器](#comfyui-管理器)
-    - [虚拟环境](#虚拟环境)
-  - [模型下载](#模型下载)
-      - [网络扩展](#网络扩展)
-    - [旧的安装方法 (MANUAL)](#旧的安装方法-manual)
-    - [依赖关系](#依赖关系)
-### 自动安装（推荐）
-
-### ComfyUI 管理器
-
-从 0.1.0 版开始，该扩展将使用 [ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager) 进行安装，这对处理各种环境下的各种安装问题大有帮助。
-
-### 虚拟环境
-还有一种试验性的单行安装方法，即在 ComfyUI 根目录下使用以下命令进行安装。它将下载代码、安装依赖项并运行安装脚本：
-
-
-```bash
-curl -sSL "https://raw.githubusercontent.com/username/repo/main/install.py" | python3 -
-```
-
-## 模型下载
-某些节点需要下载额外的模型，您可以使用与上述相同的 python 环境以交互方式完成下载：
-
-```bash
-python scripts/download_models.py
-```
-
-然后根据提示或直接按回车键下载每个模型。
-
-> **Note**
-> 您可以使用以下方法下载所有型号，无需提示：
-  ```bash
-  python scripts/download_models.py -y
-  ```
-
-#### 网络扩展
-
-首次运行时，脚本会尝试将 [网络扩展](https://github.com/melMass/comfy_mtb/tree/main/web)链接到你的 "web/extensions "文件夹，[请参阅](https://github.com/melMass/comfy_mtb/blob/d982b69a58c05ccead9c49370764beaa4549992a/__init__.py#L45-L61)。
-
-<img alt="color widget preview" src="https://github.com/melMass/comfy_mtb/assets/7041726/cff7e66a-4cc4-4866-b35b-10af0bb2d110" width=450>
-
-### 旧的安装方法 (MANUAL)
-### 依赖关系
-<details><summary><h4>Custom Virtualenv（我主要用这个）</h4></summary
-    
-1. 确保您处于用于 ComfyUI 的 Python 环境中。
-2. 运行以下命令安装所需的依赖项：
-  ```bash
-  pip install -r comfy_mtb/reqs.txt
-  ```
-
-</details>
-
-<details><summary><h4>Comfy 便携式/单机版（来自 ComfyUI 版本）</h4></summary>
-
-如果您使用 ComfyUI 单机版中的 `python-embeded `，那么当二进制文件没有轮子时，您就无法使用 pip 安装二进制文件的依赖项，在这种情况下，请查看最近的 [发布](https://github.com/melMass/comfy_mtb/releases)，那里有一个预编译轮子的 linux 和 windows 捆绑包（只有那些需要从源代码编译的轮子），请查看 [此问题 (#1)](https://github.com/melMass/comfy_mtb/issues/1) 以获取更多信息。
-![image](https://github.com/melMass/comfy_mtb/assets/7041726/2934fa14-3725-427c-8b9e-2b4f60ba1b7b)
-
-
-</details>
-
-<details><summary><h4>Google Colab</h4></summary>
-
-在 **Run ComfyUI with localtunnel (Recommended Way)** 标题之后（代码单元格之前）添加一个新的代码单元格
-
-![preview of where to add it on colab](https://github.com/melMass/comfy_mtb/assets/7041726/35df2ef1-14f9-44cd-aa65-353829188cd7)
-
-
-```python
-# download the nodes
-!git clone --recursive https://github.com/melMass/comfy_mtb.git custom_nodes/comfy_mtb
-
-# download all models
-!python custom_nodes/comfy_mtb/scripts/download_models.py -y
-
-# install the dependencies
-!pip install -r custom_nodes/comfy_mtb/reqs.txt -f https://download.openmmlab.com/mmcv/dist/cu118/torch2.0/index.html
-```
-
-如果运行后 colab 抱怨需要重新启动运行时，请重新启动，然后不要重新运行之前的单元格，只运行运行本地隧道的单元格。(可能需要先添加一个包含 `%cd ComfyUI` 的单元格）
-
-
-> **Note**:
-> If you don't need all models, remove the `-y` as collab actually supports user input: ![image](https://github.com/melMass/comfy_mtb/assets/7041726/40fc3602-f1d4-432a-98fd-ce2240f5ad06)
-
-> **Preview**
-> ![image](https://github.com/melMass/comfy_mtb/assets/7041726/b5b2b2d9-f1e8-4c43-b1db-7dfc5e07be86)
-
-</details>
-
@@ -1,93 +0,0 @@
-# インストール
-
- [インストール](#インストール)
-  - [自動インストール (推奨)](#自動インストール-推奨)
-    - [ComfyUI マネージャ](#comfyui-マネージャ)
-    - [仮想環境](#仮想環境)
-  - [モデルのダウンロード](#モデルのダウンロード)
-    - [ウェブ拡張機能](#ウェブ拡張機能)
-  - [旧インストール方法 (MANUAL)](#旧インストール方法-manual)
-    - [依存関係](#依存関係)
-
-
-## 自動インストール (推奨)
-
-### ComfyUI マネージャ
-
-バージョン0.1.0では、この拡張機能は[ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager)と一緒にインストールすることを想定しています。これは、様々な環境で直面する様々なインストール問題を処理するのに非常に役立ちます。
-
-### 仮想環境
-また、ComfyUIのルートから以下のコマンドを使用する実験的なワンライナー・インストールもあります。これはコードをダウンロードし、依存関係をインストールし、インストールスクリプトを実行します：
-
-```bash
-curl -sSL "https://raw.githubusercontent.com/username/repo/main/install.py" | python3 -
-```
-
-## モデルのダウンロード
-ノードによっては、追加モデルのダウンロードが必要な場合があるので、上記と同じ python 環境を使って対話的に行うことができる：
-```bash
-python scripts/download_models.py
-```
-
-プロンプトに従うか、Enterを押すだけで全てのモデルをダウンロードできます。
-
-
-> **Note**
-> プロンプトを出さずに全てのモデルをダウンロードするには、以下のようにします:
-  ```bash
-  python scripts/download_models.py -y
-  ```
-
-### ウェブ拡張機能
-
-初回実行時にスクリプトは[web extensions](https://github.com/melMass/comfy_mtb/tree/main/web)をあなたの快適な `web/extensions` フォルダに[シンボリックリンク](https://github.com/melMass/comfy_mtb/blob/d982b69a58c05ccead9c49370764beaa4549992a/__init__.py#L45-L61)しようとします。万が一失敗した場合は、mtbフォルダを手動で`ComfyUI/web/extensions`にコピーしてください：
-
-<img alt="color widget preview" src="https://github.com/melMass/comfy_mtb/assets/7041726/cff7e66a-4cc4-4866-b35b-10af0bb2d110" width=450>
-
-## 旧インストール方法 (MANUAL)
-### 依存関係
-
-<details><summary><h4>カスタム Virtualenv (私は主にこれを使っています)</h4></summary>
-    
-1. ComfyUIで使用しているPython環境であることを確認してください。
-2. 以下のコマンドを実行して、必要な依存関係をインストールします：
-  ```bash
-  pip install -r comfy_mtb/reqs.txt
-  ```
-
-</details> 
-
-<details><summary><h4>Comfy-portable / standalone (ComfyUI リリースより)</h4></summary>。
-    
-もしあなたがComfyUIスタンドアロンから`python-embeded`を使用している場合、バイナリがホイールを持っていない場合、依存関係をpipでインストールすることができません。この場合、最後の[リリース](https://github.com/melMass/comfy_mtb/releases)をチェックしてください。(ソースからのビルドが必要なもののみ)あらかじめビルドされたホイールがあるlinuxとwindows用のバンドルがあります。詳細は[この問題(#1)](https://github.com/melMass/comfy_mtb/issues/1)をチェックしてください。
-
-![image](https://github.com/melMass/comfy_mtb/assets/7041726/2934fa14-3725-427c-8b9e-2b4f60ba1b7b)
-
-</details>
-
-<details><summary><h4>Google Colab</h4></summary>
-
-ComfyUI with localtunnel (Recommended Way)**ヘッダーのすぐ後（コードセルの前）に、新しいコードセルを追加してください。
-![colabに追加する場所のプレビュー](https://github.com/melMass/comfy_mtb/assets/7041726/35df2ef1-14f9-44cd-aa65-353829188cd7)
-
-```python
-# download the nodes
-!git clone --recursive https://github.com/melMass/comfy_mtb.git custom_nodes/comfy_mtb
-
-# download all models
-!python custom_nodes/comfy_mtb/scripts/download_models.py -y
-
-# install the dependencies
-!pip install -r custom_nodes/comfy_mtb/reqs.txt -f https://download.openmmlab.com/mmcv/dist/cu118/torch2.0/index.html
-```
-これを実行した後、colabがランタイムを再起動する必要があると文句を言ったら、それを実行し、それ以前のセルは再実行せず、localtunnelを実行するセルだけを再実行してください。(最初に`%cd ComfyUI`のセルを追加する必要があるかもしれません...)
-
-
-> **Note**:
-> すべてのモデルが必要でない場合は、`-y`を削除してください : ![image](https://github.com/melMass/comfy_mtb/assets/7041726/40fc3602-f1d4-432a-98fd-ce2240f5ad06)
-
-> **プレビュー**
-> ![image](https://github.com/melMass/comfy_mtb/assets/7041726/b5b2b2d9-f1e8-4c43-b1db-7dfc5e07be86)
-
-</details>
-
@@ -42,7 +42,7 @@ then follow the prompt or just press enter to download every models.
 1. Make sure you are in the Python environment you use for ComfyUI.
 2. Install the required dependencies by running the following command:
  ```bash
-  pip install -r comfy_mtb/reqs.txt
+  pip install -r comfy_mtb/requirements.txt
  ```

 </details>
@@ -1,99 +0,0 @@
-# MTB Nodes
-
-<a href="https://www.buymeacoffee.com/melmass" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 32px !important;width: 140px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>
-
-[** 安装指南**](./INSTALL-CN.md) | [** 示例**](https://github.com/melMass/comfy_mtb/wiki/Examples)
-
-欢迎使用 MTB Nodes 项目！这个代码库是开放的，您可以自由地探索和利用。它的主要目的是构建用于 [MLOPs](https://github.com/Bismuth-Consultancy-BV/MLOPs) 中的概念验证（POCs）。该项目中的许多节点都是受到现有社区贡献或内置功能的启发而创建的。
-
-在继续之前，请注意与此项目中使用的某些库相关的许可证。例如，`deepbump` 库采用 [GPLv3](https://github.com/HugoTini/DeepBump/blob/master/LICENSE) 许可证。
-
- [节点列表](#节点列表)
-  - [bbox](#bbox)
-  - [colors](#colors)
-  - [人脸检测/交换](#人脸检测交换)
-  - [图像插值（动画）](#图像插值动画)
-  - [图像操作](#图像操作)
-  - [潜在变量工具](#潜在变量工具)
-  - [其他工具](#其他工具)
-  - [纹理](#纹理)
- [Comfy 资源](#comfy-资源)
-
-
-
-
-# 节点列表
-
-## bbox
- `Bounding Box`: BBox 构造函数（自定义类型）
- `BBox From Mask`: 从遮罩中提取边界框
- `Crop`: 根据边界框裁剪图像
- `Uncrop`: 根据边界框还原图像
-
-## colors
- `Colored Image`: 给定尺寸的纯色图像
- `RGB to HSV`: -
- `HSV to RGB`: -
- `Color Correct`: 基本颜色校正工具  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/7c20ac83-31ff-40ea-a1a0-06c2acefb2ef" width=345/>
-
-## 人脸检测/交换
- `Face Swap`: 使用 deepinsight/insightface 模型进行人脸交换（该节点在早期版本中称为 `Roop`，功能相同，`Roop` 只是使用这些模型的应用程序）
-  > **注意**
-  > 人脸索引允许您选择要替换的人脸，如下所示：
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/2e9d6066-c466-4a01-bd6c-315f7f1e8b42" width=320/>
- `Load Face Swap Model`: 加载 insightface 模型用于人脸交换
- `Restore Face`: 使用 [GFPGan](https://github.com/TencentARC/GFPGAN) 还原人脸，与 `Face Swap` 配合使用效果很好，并支持 `bg_upscaler` 的 Comfy 原生放大器
-  
-## 图像插值（动画）
- `Load Film Model`: 加载 [FILM](https://github.com/google-research/frame-interpolation) 模型
- `Film Interpolation`: 使用 [FILM](https://github.com/google-research/frame-interpolation) 处理输入帧  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/3afd1647-6634-4b92-a34b-51432e6a9834" width=400/>
- `Export to Prores (experimental)`: 将输入帧导出为 ProRes 4444 mov 文件。这使用 ffmpeg stdin 发送原始的 NumPy 数组，与 `Film Interpolation` 一起使用，目前很简单，但可以进一步扩展。
-
-## 图像操作
- `Blur`: 使用高斯滤波器对图像进行模糊处理。
- `Deglaze Image`: 从 [FN16](https://github.com/Fannovel16/FN16-ComfyUI-nodes/blob/main/DeglazeImage.py) 中提取
- `Denoise`: 对输入图像进行降噪处理
- `Image Compare`: 比较两个图像并返回差异图像
- `Image Premultiply`: 使用掩码对图像进行预乘处理
- `Image Remove Background Rembg`: 使用 [RemBG](https://github.com/danielgatis/rembg) 进行背景去除  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/e69253b4-c03c-45e9-92b5-aa46fb887be8" width=320/>
- `Image Resize Factor`: 大部分提取自 [WAS Node Suite](https://github.com/WASasquatch/was-node-suite-comfyui)，经过一些编辑（特别是支持多个图像）和较少的功能。
- `Mask To Image`: 将遮罩（Alpha）转换为带有颜色和背景的 RGB 图像
- `Save Image Grid`: 将输入批次中的所有图像保存为图像网格。
-
-## 潜在变量工具
- `Latent Lerp`: 两个潜在变量之间的线性插值（混合）
-
-
-## 其他工具
- `Concat Images`: 接受两个图像流，并将它们合并为其他 Comfy 管道支持的图像批次。
- `Image Resize Factor`: **已弃用**，因为我后来发现了内
-
-置的图像调整大小功能。
- `Text To Image`: 使用字体将文本转换为图像的工具
- `Styles Loader`: 加载 csv 文件并从行中填充下拉列表（类似于 A111）  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/02fe3211-18ee-4e54-a029-931388f5fde8" width=320/>
- `Smart Step`: 一个非常基本的节点，用于获取在 KSampler 高级中使用的步骤百分比
- `Qr Code`: 基本的 QR Code 生成器
- `Save Tensors`: 调试节点，将来可能会被删除
- `Int to Number`: 用于 WASSuite 数字节点的补充
- `Smart Step`: 使用百分比来控制 `KAdvancedSampler` 的步骤（开始/停止）
-
-## 纹理
-
- `DeepBump`: 从单张图片生成法线图和高度图
-
-# Comfy 资源
-
-**指南**:
- [官方示例（英文）](https://comfyanonymous.github.io/ComfyUI_examples/)
- @BlenderNeko 的[ComfyUI 社区手册（英文）](https://blenderneko.github.io/ComfyUI-docs/)
-
- @tjhayasaka 的[Tomoaki 个人 Wiki（日文）](https://comfyui.creamlab.net/guides/)
-
-**扩展和自定义节点**:
- @WASasquatch 的[Comfy 列表插件（英文）](https://github.com/WASasquatch/comfyui-plugins)
-
- [CivitAI 上的 ComfyUI 标签（英文）](https://civitai.com/tag/comfyui)
@@ -1,96 +0,0 @@
-# MTB Nodes
-
-<a href="https://www.buymeacoffee.com/melmass" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 32px !important;width: 140px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>
-
-[**インストールガイド**](./INSTALL-JP.md) | [**サンプル**](https://github.com/melMass/comfy_mtb/wiki/Examples)
-
-MTB Nodesプロジェクトへようこそ！このコードベースは、自由に探索し、利用することができます。主な目的は、[MLOPs](https://github.com/Bismuth-Consultancy-BV/MLOPs)の実装のための概念実証（POC）を構築することです。このプロジェクトの多くのノードは、既存のコミュニティの貢献や組み込みの機能に触発されています。
-
-続行する前に、このプロジェクトで使用されている特定のライブラリに関連するライセンスに注意してください。たとえば、「deepbump」ライブラリは、[GPLv3](https://github.com/HugoTini/DeepBump/blob/master/LICENSE)の下でライセンスされています。
-
- [ノードリスト](#ノードリスト)
-  - [bbox](#bbox)
-  - [colors](#colors)
-  - [顔検出 / スワッピング](#顔検出--スワッピング)
-  - [画像補間（アニメーション）](#画像補間アニメーション)
-  - [画像操作](#画像操作)
-  - [潜在的なユーティリティ](#潜在的なユーティリティ)
-  - [その他のユーティリティ](#その他のユーティリティ)
-  - [テクスチャ](#テクスチャ)
- [Comfyリソース](#comfyリソース)
-
-
-# ノードリスト
-
-## bbox
- `Bounding Box`: BBoxコンストラクタ（カスタムタイプ）
- `BBox From Mask`: マスクからバウンディングボックスを抽出
- `Crop`: BBoxから画像を切り抜く
- `Uncrop`: BBoxから画像を元に戻す
-
-## colors
- `Colored Image`: 指定されたサイズの一定の色の画像
- `RGB to HSV`: -
- `HSV to RGB`: -
- `Color Correct`: 基本的なカラーコレクションツール  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/7c20ac83-31ff-40ea-a1a0-06c2acefb2ef" width=345/>
-
-## 顔検出 / スワッピング
- `Face Swap`: deepinsight/insightfaceモデルを使用した顔の入れ替え（このノードは初期バージョンでは「Roop」と呼ばれていましたが、同じ機能を提供します。Roopは単にこれらのモデルを使用するアプリです）
-  > **注意**
-  > 顔のインデックスを使用して置き換える顔を選択できます。以下を参照してください：
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/2e9d6066-c466-4a01-bd6c-315f7f1e8b42" width=320/>
- `Load Face Swap Model`: 顔の交換のためのinsightfaceモデルを読み込む
- `Restore Face`: [GFPGan](https://github.com/TencentARC/GFPGAN)を使用して顔を復元し、`Face Swap`と組み合わせて使用すると非常に効果的であり、`bg_upscaler`のComfyネイティブアップスケーラーもサポートしています。
-
-## 画像補間（アニメーション）
- `Load Film Model`: [FILM](https://github.com/google-research/frame-interpolation)モデルを読み込む
- `Film Interpolation`: [FILM](https://github.com/google-research/frame-interpolation)を使用して入力フレームを処理する  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/3afd1647-6634-4b92-a34b-51432e6a9834" width=400/>
- `Export to Prores (experimental)`: 入力フレームをProRes 4444 movファイルにエクスポートします。これは現在は単純なものですが、`Film Interpolation`と組み合わせて使用するためのffmpegのstdinを使用して生のNumPy配列を送信するもので、拡張することもできます。
-
-## 画像操作
- `Blur`: ガウスフィルタを使用して画像をぼかす
- `Deglaze Image`: [FN16](https://github.com/Fannovel16/FN16-ComfyUI-nodes/blob/main/DeglazeImage.py)から取得
- `Denoise`: 入力画像のノイズを除去する
- `Image Compare`: 2つの画像を比較し、差分画像を返す
- `Image Premultiply`: 画像をマスクで乗算
- `Image Remove Background Rembg`: [RemBG](https://github.com/danielgatis/rembg)を使用した背景除去  
-  <img src="https://github.com/melMass/comfy_mtb/assets/704172
-
-6/e69253b4-c03c-45e9-92b5-aa46fb887be8" width=320/>
- `Image Resize Factor`: [WAS Node Suite](https://github.com/WASasquatch/was-node-suite-comfyui)から抽出され、いくつかの編集（特に複数の画像のサポート）と機能の削減が行われました。
- `Mask To Image`: マスク（アルファ）をカラーと背景を持つRGBイメージに変換します。
- `Save Image Grid`: 入力バッチのすべての画像を画像グリッドとして保存します。
-
-## 潜在的なユーティリティ
- `Latent Lerp`: 2つの潜在的なベクトルの間の線形補間（ブレンド）
-
-## その他のユーティリティ
- `Concat Images`: 2つの画像ストリームを取り、他のComfyパイプラインでサポートされている画像のバッチとしてマージします。
- `Image Resize Factor`: **非推奨**。組み込みの画像リサイズ機能を発見したため、削除される予定です。
- `Text To Image`: フォントを使用してテキストを画像に変換するためのユーティリティ
- `Styles Loader`: csvファイルをロードし、行からドロップダウンを作成します（A111のようなもの）  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/02fe3211-18ee-4e54-a029-931388f5fde8" width=320/>
- `Smart Step`: KSamplerの高度な使用に使用するステップパーセントを取得する非常に基本的なノード
- `Qr Code`: 基本的なQRコード生成器
- `Save Tensors`: 将来的に削除される可能性のあるデバッグノード
- `Int to Number`: WASSuiteの数値ノードの補完
- `Smart Step`: `KAdvancedSampler`のステップ（開始/停止）を制御するための非常に基本的なツールで、パーセンテージを使用します。
-
-## テクスチャ
-
- `DeepBump`: 1枚の画像から法線マップと高さマップを生成します。
-
-# Comfyリソース
-
-**ガイド**:
- [公式の例（英語）](https://comfyanonymous.github.io/ComfyUI_examples/)
- @BlenderNekoによる[ComfyUIコミュニティマニュアル（英語）](https://blenderneko.github.io/ComfyUI-docs/)
-
- @tjhayasakaによる[Tomoakiの個人Wiki（日本語）](https://comfyui.creamlab.net/guides/)
-
-**拡張機能とカスタムノード**:
- @WASasquatchによる[Comfyリスト用のプラグイン（英語）](https://github.com/WASasquatch/comfyui-plugins)
-
- [CivitAIのComfyUIタグ（英語）](https://civitai.com/tag/comfyui)
@@ -4,171 +4,8 @@
 ![home](https://repository-images.githubusercontent.com/649047066/a3eef9a7-20dd-4ef9-b839-884502d4e873)

 <!-- omit in toc -->
-
-**Translated Readme (using DeepTranslate, PRs are welcome)**:  
-![image](https://github.com/melMass/comfy_mtb/assets/7041726/f8429c14-3521-4e28-82a3-863d781976c0)
-[日本語による説明](./README-JP.md)  
-![image](https://github.com/melMass/comfy_mtb/assets/7041726/d5cc1fdd-2820-4a5c-b2d7-482f1c222063)
-[中文说明](./README-CN.md)
-
 <a href="https://www.buymeacoffee.com/melmass" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 32px !important;width: 140px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>

-[**Install Guide**](./INSTALL.md) | [**Examples**](https://github.com/melMass/comfy_mtb/wiki/Examples)
-
-Welcome to the MTB Nodes project! This codebase is open for you to explore and utilize as you wish. Its primary purpose is to build proof-of-concepts (POCs) for implementation in [MLOPs](https://github.com/Bismuth-Consultancy-BV/MLOPs). Many nodes in this project are inspired by existing community contributions or built-in functionalities.
-
-Before proceeding, please be aware of the licenses associated with certain libraries used in this project. For example, the `deepbump` library is licensed under [GPLv3](https://github.com/HugoTini/DeepBump/blob/master/LICENSE).
-
- [Web Extensions](#web-extensions)
- [Node List](#node-list)
-  - [Animation](#animation)
-  - [bbox](#bbox)
-  - [colors](#colors)
-  - [image ops](#image-ops)
-  - [latent utils](#latent-utils)
-  - [textures](#textures)
-  - [misc utils](#misc-utils)
-  - [Optional nodes](#optional-nodes)
-    - [face detection / swapping](#face-detection--swapping)
-    - [image interpolation (animation)](#image-interpolation-animation)
- [Comfy Resources](#comfy-resources)
-
-# Web Extensions
-mtb add a few widgets like `COLOR`
-
-<img alt="color widget preview" src="https://github.com/melMass/comfy_mtb/assets/7041726/cff7e66a-4cc4-4866-b35b-10af0bb2d110" width=450>
-
-A few nodes have the concept of "dynamic" inputs:  
-<img alt="dynamic inputs" width=450  src="https://github.com/melMass/comfy_mtb/assets/7041726/10b3976e-b212-4968-91eb-f34c02bb80c3" />
+[**Wiki**](https://github.com/melMass/comfy_mtb/wiki) | [**Install Guide**](./INSTALL.md) | [**Examples**](https://github.com/melMass/comfy_mtb/wiki/Examples)


-# Node List
-
-## Animation
- `Animation Builder`: Convenient way to manage basic animation maths at the core of many of my workflows (both worflows for the following GIFs are in the [examples](https://github.com/melMass/comfy_mtb/wiki/Examples))  
-
-  **[Example lerping two conditions (blue car -> yellow car)](https://github.com/melMass/comfy_mtb/blob/main/examples/03-animation_builder-condition-lerp.json)**
-  
-  <img width=300 src="https://user-images.githubusercontent.com/7041726/260258970-d6d66d96-fb34-40d0-9038-cbabf0714c5d.gif"/>  
-  
-
-  **[Example using image transforms a feedback for a fake deforum effect](https://github.com/melMass/comfy_mtb/blob/main/examples/04-animation_builder-deforum.json)**
-  
-  <img width=300 src="https://user-images.githubusercontent.com/7041726/260261504-303a1037-60d3-4b31-a589-b15d549752f6.gif"/>
-  
- `Batch Float`: Generates a batch of float values with interpolation.
- `Batch Shape`: Generates a batch of 2D shapes with optional shading (experimental).
- `Batch Transform`: Transform a batch of images using a batch of keyframes.  
-  <img width=400 src="https://github.com/melMass/comfy_mtb/assets/7041726/3f217de1-79aa-49b0-a66a-35cf29dd8f01"/>
- `Export With Ffmpeg`: Export with FFmpeg, it used to be export to Proress and is still tailored for YUV
- `Fit Number` : Fit the input float using a source and target range, you can also control the interpolation curve from a list of presets (default to linear)
-  
-## bbox
- `Bounding Box`: BBox constructor (custom type),
- `BBox From Mask`: From a mask extract the bounding box
- `Crop`: Crop image from BBox
- `Uncrop`: Uncrop image from BBox
-
-## colors
- `Colored Image`: Constant color image of given size
- `RGB to HSV`: -,
- `HSV to RGB`: -,
- `Color Correct`: Basic color correction tools  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/7c20ac83-31ff-40ea-a1a0-06c2acefb2ef" width=400/>
-
-## image ops
- `Blur`: Blur an image using a Gaussian filter.
- `Deglaze Image`: taken from [FN16](https://github.com/Fannovel16/FN16-ComfyUI-nodes/blob/main/DeglazeImage.py),
- `Denoise`: Denoise the input image,
- `Image Compare`: Compare two images and return a difference image
- `Image Premultiply`: Premultiply image with mask
- `Image Remove Background Rembg`: [RemBG](https://github.com/danielgatis/rembg) powered background removal.  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/e69253b4-c03c-45e9-92b5-aa46fb887be8" width=320/>
- `Image Resize Factor`: Extracted mostly from [WAS Node Suite](https://github.com/WASasquatch/was-node-suite-comfyui), with a few edits (most notably multiple image support) and less features.
- `Mask To Image`: Converts a mask (alpha) to an RGB image with a color and background
- `Save Image Grid`: Save all the images in the input batch as a grid of images.
-
-## latent utils
- `Latent Lerp`: Linear interpolation (blend) between two latent 
-
-## textures
- `Model Patch Seamless`: Use the [seamless diffusion "hack"](https://gitlab.com/-/snippets/2395088) to patch any model to infere seamless images, check the [examples](https://github.com/melMass/comfy_mtb/wiki/Examples) to see how to use all those textures node together  
-  <img width=500 src="https://user-images.githubusercontent.com/7041726/272970506-9db516b5-45d2-4389-b904-b3a94660f24c.png"/>
- `DeepBump`: Normal & height maps generation from single pictures  
-  <img width=500 src="https://user-images.githubusercontent.com/7041726/272970715-7e4477f6-8e18-4839-9864-83d07d6690a1.png"/>
- `Image Tile Offset`: Mimics an old photoshop technique to check for seamless textures by offsetting tiles of the image.  
-  <img width=600 src="https://github.com/melMass/comfy_mtb/assets/7041726/cbcc51fb-922f-433f-acf1-c6c6c2a7ffc4" />
-
-## misc utils
- `Any To String`: Tries to take any input and convert it to a string.
- `Concat Images`: Takes two image stream and merge them as a batch of images supported by other Comfy pipelines.
- `Image Resize Factor`: **Deprecated**, I since discovered the builtin image resize.
- `Text To Image`: Utils to convert text to image using a font
- `Styles Loader`: Load csv files and populate a dropdown from the rows (à la A111)  
-  <img src="https://github.com/melMass/comfy_mtb/assets/7041726/02fe3211-18ee-4e54-a029-931388f5fde8" width=320/>
- `Smart Step`: A very basic node to get step percent to use in KSampler advanced,
- `Qr Code`: Basic QR Code generator
- `Save Tensors`: Debug node that will probably be removed in the future
- `Int to Number`: Supplement for WASSuite number nodes
- `Smart Step`: A very basic tool to control the steps (start/stop) of the `KAdvancedSampler` using percentage
- `Load Image From Url`: Load an image from the given URL
-
-
-## Optional nodes
-
-These nodes are still bundled in mtb, but moving forward (>0.2.0) they won't
-be setup by the install script and their dependencies won't install either.
-The reason is mostly that they all have a better alternatives available and tensorflow on windows was not a fun experience and since Python 3.11 not an experience at all.
-
-For linux and mac users though these nodes didn't cause any issue and I personally still use them, these are the extra requirements needed:
-
-```console
-.venv/python -m pip install tensorflow facexlib insightface basicsr
-```
-
-### face detection / swapping
-> **Warning**
-> Those nodes were among the first to be implemented they do work, but on windows the installation is still not properly handled for everyone  
-> As alternatives you can use [reactor](https://github.com/Gourieff/comfyui-reactor-node) for face swap and [facerestore](https://github.com/Haidra-Org/hordelib/tree/main/hordelib/nodes/facerestore) for restoration  
-> You can check [this video](https://www.youtube.com/watch?v=FShlpMxbU0E) for a tutorial by Ferniclestix using these alternatives  
-
- `Face Swap`: Face swap using deepinsight/insightface models (this node used to be called `Roop` in early versions, it does the same, roop is *just* an app that uses those model)  
-  <img  width=320 src="https://user-images.githubusercontent.com/7041726/260261217-54e33446-183f-4dda-88b3-d38a1e6de980.gif"/>
- `Load Face Swap Model`: Load an insightface model for face swapping
- `Restore Face`: Using [GFPGan](https://github.com/TencentARC/GFPGAN) to restore faces, works great in conjunction with `Face Swap` and supports Comfy native upscalers for the `bg_upscaler`
-  
-### image interpolation (animation)
-> **Warning**
-> The FILM nodes will be deprecated at some point after 0.2.0, [Fannovel16](https://github.com/Fannovel16/ComfyUI-Frame-Interpolation)'s interpolation nodes implement it and they rely on a pytorch implementation of FILM
-> which solves the issues related to the ones included in mtb. They will probably remain available if your system meet the requirements and ignored otherwise.
-
-<details><summary>Why?</summary>
-  
-> **Windows only issue**: This requires tensorflow-gpu that is unfortunately not a thing anymore on Windows since 2.10.1 (unless you use a complex WSL passthrough setup but it's still not "Windows")  
-> Using this old version is quite clunky and require some patching that install.py does automatically, but the main issue is that no wheels are available for python > 3.10
-> Comfy-nightly is already using Python 11 so installing this old tf version won't work there.  
-> You can in any case install the normal up to date tensorflow but that will run on CPU and is much MUCH slower for FILM inference.
-</details>
-
- `Load Film Model`: Loads a [FILM](https://github.com/google-research/frame-interpolation) model
- `Film Interpolation`: Process input frames using [FILM](https://github.com/google-research/frame-interpolation)  
-  <img width=400 src="https://github.com/melMass/comfy_mtb/assets/7041726/3afd1647-6634-4b92-a34b-51432e6a9834"/>  
-  <img width=400 src="https://user-images.githubusercontent.com/7041726/260259079-c0f04a63-960c-43a7-ba78-a45cd5ac7514.gif"/>
- `Export to Prores (experimental)`: Exports the input frames to a ProRes 4444 mov file. This is using ffmpeg stdin to send raw numpy arrays, used with `Film Interpolation` and very simple for now but could be expanded upon.
-
-# Comfy Resources
-
-**Misc**
-
- [Slick ComfyUI by NoCrypt](https://colab.research.google.com/drive/1ZMvLWEiYITmBJngtqeIQToeNuiydwI0z#scrollTo=1fWMaexXS188): A colab notebook with batteries included!
-
-**Guides**:
- [Official Examples (eng)](https://comfyanonymous.github.io/ComfyUI_examples/)
- [ComfyUI Community Manual (eng)](https://blenderneko.github.io/ComfyUI-docs/) by @BlenderNeko
-  
- [Tomoaki's personal Wiki (jap)](https://comfyui.creamlab.net/guides/) by @tjhayasaka
-
-**Extensions and Custom Nodes**:
- [Plugins for Comfy List (eng)](https://github.com/WASasquatch/comfyui-plugins) by @WASasquatch
-
- [ComfyUI tag on CivitAI (eng)](https://civitai.com/tag/comfyui)
@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding:utf-8 -*-
 ###
 # File: __init__.py
 # Project: comfy_mtb
@@ -7,21 +6,27 @@
 # Copyright (c) 2023 Mel Massadian
 #
 ###
+
+__version__ = "0.1.6"
+
 import os

-# todo: don't override this if the user has that setup already
-os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"
-os.environ["TF_GPU_ALLOCATOR"] = "cuda_malloc_async"
+# TODO: don't override this if the user has that setup already
+if not os.environ.get("TF_FORCE_GPU_ALLOW_GROWTH"):
+    os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"
+
+if not os.environ.get("TF_GPU_ALLOCATOR"):
+    os.environ["TF_GPU_ALLOCATOR"] = "cuda_malloc_async"

 import ast
 import contextlib
 import importlib
 import json
 import logging
-import os
 import shutil
 import traceback
 from importlib import reload
+from pathlib import Path

 from aiohttp import web
 from server import PromptServer
@@ -37,14 +42,11 @@ NODE_DISPLAY_NAME_MAPPINGS = {}
 NODE_CLASS_MAPPINGS_DEBUG = {}
 WEB_DIRECTORY = "./web"

-__version__ = "0.2.0"

-
-def extract_nodes_from_source(filename):
+def extract_nodes_from_source(filename: Path):
    source_code = ""

-    with open(filename, "r", encoding="utf8") as file:
-        source_code = file.read()
+    source_code = filename.read_text(encoding="utf-8")

    nodes = []

@@ -69,7 +71,7 @@ def extract_nodes_from_source(filename):


 def load_nodes():
-    errors = []
+    errors: list[str] = []
    nodes = []
    nodes_failed = []

@@ -81,14 +83,16 @@ def load_nodes():
                module = importlib.import_module(
                    f".nodes.{module_name}", package=__package__
                )
-                _nodes = getattr(module, "__nodes__")
+                _nodes = getattr(module, "__nodes__", [])
                nodes.extend(_nodes)
                log.debug(f"Imported {module_name} nodes")

            except AttributeError:
+                log.debug(f"Skipping wip module {module_name}")
                pass  # wip nodes
            except Exception:
                error_message = traceback.format_exc().splitlines()[-1]
+
                errors.append(
                    f"Failed to import module {module_name} because {error_message}"
                )
@@ -97,7 +101,7 @@ def load_nodes():

    if errors:
        log.debug(
-            f"Some nodes failed to load:\n\t"
+            "Some nodes failed to load:\n\t"
            + "\n\t".join(errors)
            + "\n\n"
            + "Check that you properly installed the dependencies.\n"
@@ -108,25 +112,82 @@ def load_nodes():


 # - REGISTER WEB EXTENSIONS
-web_extensions_root = comfy_dir / "web" / "extensions"
-web_mtb = web_extensions_root / "mtb"
+def uninstall_old_web_extensions():
+    web_extensions_root = comfy_dir / "web" / "extensions"
+    web_mtb = web_extensions_root / "mtb"

-if web_mtb.exists() and hasattr(nodes, "EXTENSION_WEB_DIRS"):
-    try:
-        if web_mtb.is_symlink():
-            web_mtb.unlink()
-        else:
-            shutil.rmtree(web_mtb)
-    except Exception as e:
-        log.warning(
-            f"Failed to remove web mtb directory: {e}\nPlease manually remove it from disk ({web_mtb}) and restart the server."
-        )
+    if web_mtb.exists() and hasattr(nodes, "EXTENSION_WEB_DIRS"):
+        try:
+            if web_mtb.is_symlink():
+                web_mtb.unlink()
+            else:
+                shutil.rmtree(web_mtb)
+        except Exception as e:
+            log.warning(
+                f"Failed to remove web mtb directory: {e}\nPlease manually remove it from disk ({web_mtb}) and restart the server."
+            )
+
+
+# uninstall_old_web_extensions()
+
+
+# - GATHER WIKI PAGES
+def wiki_to_classname(s: str):
+    wiki_name = s.replace("nodes-", "", 1)
+    return "MTB_" + "".join(
+        [part.capitalize() for part in wiki_name.split("-")]
+    )
+
+
+def classname_to_wiki(s: str):
+    classname = s.replace("MTB_", "")
+    parts = []
+    start = 0
+    for i in range(1, len(classname)):
+        if classname[i].isupper():
+            parts.append(classname[start:i].lower())
+            start = i
+    parts.append(classname[start:].lower())
+    return "nodes-" + "-".join(parts)
+
+
+wiki = here / "wiki"
+node_docs = {}
+if wiki.exists() and wiki.is_dir():
+    node_docs = {
+        wiki_to_classname(x.stem): x.read_text(encoding="utf-8")
+        for x in (wiki / "nodes").glob("*.md")
+    }


 # - REGISTER NODES
+
+
+MTB_EXPORT = os.environ.get("MTB_EXPORT")
+
 nodes, failed = load_nodes()
 for node_class in nodes:
-    class_name = node_class.__name__
+    class_name: str = node_class.__name__
+    linked_doc = node_docs.get(class_name)
+
+    if not hasattr(node_class, "DESCRIPTION"):
+        if linked_doc:
+            log.debug(f"Found linked doc for {class_name}, using it")
+            node_class.DESCRIPTION = linked_doc
+        elif node_class.__doc__:
+            log.debug(f"Using __doc__ as description for {class_name}")
+            node_class.DESCRIPTION = node_class.__doc__
+            if MTB_EXPORT:
+                wiki_name = classname_to_wiki(class_name)
+                (wiki / "nodes" / (wiki_name + ".md")).write_text(
+                    node_class.__doc__, encoding="utf-8"
+                )
+
+        else:
+            log.debug(
+                f"None of the methods could retrieve documentation for {class_name}"
+            )
+
    node_label = f"{get_label(class_name)} (mtb)"
    NODE_CLASS_MAPPINGS[node_label] = node_class
    NODE_DISPLAY_NAME_MAPPINGS[class_name] = node_label
@@ -147,7 +208,7 @@ for node_class in nodes:
            )

 log.debug(
-    f"Loaded the following nodes:\n\t"
+    "Loaded the following nodes:\n\t"
    + "\n\t".join(
        f"{cyan_text(k)}: {blue_text(get_summary(doc)) if doc else '-'}"
        for k, doc in NODE_CLASS_MAPPINGS_DEBUG.items()
@@ -182,6 +243,12 @@ if hasattr(PromptServer, "instance"):
        "/mtb-assets/", path=(here / "html").as_posix()
    )

+    # NOTE: we add an extra static path to avoid comfy mechanism
+    # that loads every script in web.
+    PromptServer.instance.app.add_routes(
+        [web.static("/mtb_async", (here / "web_async").as_posix())]
+    )
+
    @PromptServer.instance.routes.get("/mtb/manage")
    async def manage(request):
        from . import endpoint
@@ -270,7 +337,7 @@ if hasattr(PromptServer, "instance"):
                <a href="/mtb/manage">manage</a>
                <a href="/mtb/debug">debug</a>
                <a href="/mtb/status">status</a>
-            </div>            
+            </div>
            """
            return web.Response(
                text=endpoint.render_base_template("MTB", html_response),
@@ -0,0 +1,31 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.6.1/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "suspicious": {
+        "noConsoleLog": "warn"
+      },
+      "style": {
+        "noParameterAssign": "off",
+        "noShoutyConstants": "warn",
+        "useNamingConvention": "off"
+      }
+    }
+  },
+  "formatter": {
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineEnding": "lf"
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "semicolons": "asNeeded"
+    }
+  }
+}
@@ -3,12 +3,17 @@ import csv
 from aiohttp import web

 from .log import mklog
-from .utils import backup_file, here, import_install, reqs_map, run_command, styles_dir
+from .utils import (
+    backup_file,
+    import_install,
+    reqs_map,
+    run_command,
+    styles_dir,
+)

 endlog = mklog("mtb endpoint")

 # - ACTIONS
-import platform
 import sys
 from pathlib import Path

@@ -22,7 +27,9 @@ def ACTIONS_installDependency(dependency_names=None):
    # reqs = []
    resolved_names = [reqs_map.get(name, name) for name in dependency_names]
    try:
-        run_command([Path(sys.executable), "-m", "pip", "install"] + resolved_names)
+        run_command(
+            [Path(sys.executable), "-m", "pip", "install"] + resolved_names
+        )
        return {"success": True}

    except Exception as e:
@@ -44,9 +51,9 @@ def ACTIONS_installDependency(dependency_names=None):


 def ACTIONS_getStyles(style_name=None):
-    from .nodes.conditions import StylesLoader
+    from .nodes.conditions import MTB_StylesLoader

-    styles = StylesLoader.options
+    styles = MTB_StylesLoader.options
    match_list = ["name"]
    if styles:
        filtered_styles = {
@@ -55,7 +62,9 @@ def ACTIONS_getStyles(style_name=None):
            if not key.startswith("__") and key not in match_list
        }
        if style_name:
-            return filtered_styles.get(style_name, {"error": "Style not found"})
+            return filtered_styles.get(
+                style_name, {"error": "Style not found"}
+            )
        return filtered_styles
    return {"error": "No styles found"}

@@ -75,7 +84,9 @@ def ACTIONS_saveStyle(data):
            break

    if not target:
-        endlog.warning(f"Could not determine the target file for {data.keys()}")
+        endlog.warning(
+            f"Could not determine the target file for {data.keys()}"
+        )
        return {"error": "Could not determine the target file for the style"}

    backup_file(target)
@@ -103,11 +114,16 @@ async def do_action(request) -> web.Response:
        return web.json_response({"result": result})

    available_methods = [
-        attr[len("ACTIONS_") :] for attr in globals() if attr.startswith("ACTIONS_")
+        attr[len("ACTIONS_") :]
+        for attr in globals()
+        if attr.startswith("ACTIONS_")
    ]

    return web.json_response(
-        {"error": "Invalid method name.", "available_methods": available_methods}
+        {
+            "error": "Invalid method name.",
+            "available_methods": available_methods,
+        }
    )


@@ -127,7 +143,7 @@ def csv_editor():

    style_files = {}
    for file in inputs:
-        with open(file, "r", encoding="utf8") as f:
+        with open(file, encoding="utf8") as f:
            parsed = csv.reader(f)
            style_files[file.name] = []
            for row in parsed:
@@ -235,7 +251,9 @@ def add_split_pane(left_content, right_content, vertical=True):


 def add_dropdown(title, options):
-    option_str = "\n".join([f"<option value='{opt}'>{opt}</option>" for opt in options])
+    option_str = "\n".join(
+        [f"<option value='{opt}'>{opt}</option>" for opt in options]
+    )
    return f"""
    <select>
        <option disabled selected>{title}</option>
@@ -254,11 +272,15 @@ def render_table(table_dict, sort=True, title=None):
        if isinstance(item, dict):
            if "dependencies" in item:
                table_rows += f"<tr><td>{name}</td><td>"
-                table_rows += f"{dependencies_button(name,item['dependencies'])}"
+                table_rows += (
+                    f"{dependencies_button(name,item['dependencies'])}"
+                )

                table_rows += "</td></tr>"
            else:
-                table_rows += f"<tr><td>{name}</td><td>{render_table(item)}</td></tr>"
+                table_rows += (
+                    f"<tr><td>{name}</td><td>{render_table(item)}</td></tr>"
+                )
        # elif isinstance(item, str):
        #     table_rows += f"<tr><td>{name}</td><td>{item}</td></tr>"
        else:
@@ -0,0 +1,161 @@
+# NOTE: This file is only use for development you can ignore it
+
+def get_root [--clean] {
+    if $clean {
+        $env.COMFY_CLEAN_ROOT
+    } else {
+        $env.COMFY_ROOT
+    }
+}
+
+export def "comfy build-web" [] {
+    cd $env.COMFY_MTB
+    cd web_source
+    npm run build
+    cp dist/*.js ../web/dist
+}
+
+export def "comfy dev-web" [] {
+    cd $env.COMFY_MTB
+    cd web_source
+    npm run dev
+}
+
+
+# start the comfy server
+export def "comfy start" [--clean,--old-ui, --listen] {
+
+    let root = get_root --clean=($clean)
+    cd $root
+    MTB_DEBUG=true python main.py --port 3000 ...(if $old_ui { ["--front-end-version", "Comfy-Org/ComfyUI_legacy_frontend@latest"]} else {[]}) --preview-method auto ...(if $listen {["--listen"]} else {[]})
+}
+
+# update comfy itself and merge master in current branch
+export def "comfy update" [
+    --clean # ??
+    --rebase # Rebase instead of merge
+] {
+    let root = get_root --clean=($clean)
+    let models = $"($root)/models"
+    let inputs = $"($root)/input"
+    cd $root
+    let branch_name = (git rev-parse --abbrev-ref HEAD | str trim)
+    print $"(ansi yellow_italic)Backing up and removing models symlinks(ansi reset)"
+
+    if not $clean {
+        cd $models
+        # find all symlinks
+        let links = (ls -la |
+            where not ($it.target | is-empty) |
+            select name target |
+            sort-by name)
+
+
+            if not ($links | is-empty) {
+              $links | save -f links.nuon
+              # remove them
+              open links.nuon | each {|p| rm $p.name }
+            }
+    } else {
+        rm $models
+        rm $inputs
+    }
+
+    cd $root
+
+    print $"(ansi yellow_italic)Checking out to master(ansi reset)"
+    git checkout master
+
+    print $"(ansi yellow_italic)Fetching and pulling remote updates(ansi reset)"
+    git fetch
+    git pull
+
+    print $"(ansi yellow_italic)Back to our branch \(($branch_name)\)(ansi reset)"
+    git checkout -
+
+    if $rebase {
+        print $"(ansi yellow_italic)Rebasing changes(ansi reset)"
+        git rebase master
+
+    } else {
+        print $"(ansi yellow_italic)Merging changes(ansi reset)"
+        git merge master
+    }
+
+    print $"(ansi yellow_italic)Linking back the models(ansi reset)"
+
+    if not $clean {
+        cd $models
+        # resymlink them
+        open links.nuon | each {|p| link -a $p.target $p.name }
+    } else {
+        let master = (get_root)
+        link ($master | path join models) $models
+        link ($master | path join input) $inputs
+    }
+
+    let commit_count = (git rev-list --count $branch_name $"^origin/($branch_name)")
+
+
+    print $"(ansi green_bold)Update successful \(($commit_count) new commits\)(ansi reset)"
+
+
+}
+
+export def "comfy toggle_extensions" [--clean] {
+    let root = get_root --clean=($clean)
+    cd $root
+    cd custom_nodes
+    let exts = (ls | where type in ["dir","symlink"] | get name)
+    let choices = ($exts | input list -m "choose extension to toggle")
+    if ($choices | is-empty) {
+        return
+    }
+
+    print $choices
+
+    let filtered = $choices | wrap name | upsert enabled {|p| not ($p.name | str ends-with ".disabled")}
+
+    print $filtered
+    $filtered | each {|f|
+        let new_name = ($f.name | str replace ".disabled" "")
+
+        let new_name = if $f.enabled {
+            $"($new_name).disabled"
+        } else {
+            $new_name
+        }
+        print $"Moving ($f.name) to ($new_name)"
+        mv $f.name $new_name
+    }
+}
+
+# git pull all extensions
+export def "comfy update_extensions" [--clean] {
+    let root = get_root --clean=($clean)
+    cd $root
+    cd custom_nodes
+    git multipull .
+}
+
+def --env path-add [pth] {
+    $env.PATH = ($env.PATH | append ($pth | path expand))
+
+}
+
+
+export-env {
+  $env.COMFY_MTB = ("." | path expand)
+  $env.CUDA_ROOT =  'C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\'
+
+  $env.CUDA_HOME = $env.CUDA_ROOT
+
+  $env.COMFY_ROOT = ("../.." | path expand)
+  $env.COMFY_CLEAN_ROOT =  ($env.COMFY_ROOT | path dirname | path join ComfyClean)
+
+  path-add 'C:/Portable/TensorRT-8.6.0.12/lib'
+  path-add ($env.CUDA_ROOT | path join bin)
+  overlay use ../../.venv/Scripts/activate.nu
+}
+
+
@@ -36,7 +36,7 @@ class Formatter(logging.Formatter):
        return formatter.format(record)


-def mklog(name, level=base_log_level):
+def mklog(name: str, level: int = base_log_level):
    logger = logging.getLogger(name)
    logger.setLevel(level)

@@ -58,24 +58,30 @@ def mklog(name, level=base_log_level):
 log = mklog(__package__, base_log_level)


-def log_user(arg):
-    print("\033[34mComfy MTB Utils:\033[0m {arg}")
+def log_user(arg: str):
+    print(f"\033[34mComfy MTB Utils:\033[0m {arg}")


-def get_summary(docstring):
+def get_summary(docstring: str):
    return docstring.strip().split("\n\n", 1)[0]


-def blue_text(text):
+def blue_text(text: str):
    return f"\033[94m{text}\033[0m"


-def cyan_text(text):
+def cyan_text(text: str):
    return f"\033[96m{text}\033[0m"


-def get_label(label):
+def get_label(label: str):
    if label.startswith("MTB_"):
        label = label[4:]
-    words = re.findall(r"(?:^|[A-Z])[a-z]*", label)
+
+    words = re.findall(
+        r"(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[A-Za-z])(?=[0-9])|(?<=[0-9])(?=[A-Za-z]))",
+        label,
+    )
+    reformatted_label = re.sub(r"([A-Z]+)", r" \1", label).strip()
+    words = reformatted_label.split()
    return " ".join(words).strip()
@@ -1,7 +1,7 @@
 from ..log import log


-class AnimationBuilder:
+class MTB_AnimationBuilder:
    """Simple maths for animation."""

    @classmethod
@@ -21,6 +21,36 @@ class AnimationBuilder:
    RETURN_NAMES = ("frame", "0-1 (scaled)", "count", "loop_ended")
    CATEGORY = "mtb/animation"
    FUNCTION = "build_animation"
+    DESCRIPTION = """
+# Animation Builder
+
+Check the
+[wiki page](https://github.com/melMass/comfy_mtb/wiki/nodes-animation-builder)
+for more info.
+
+
+- This basic example should help to understand the meaning of
+its inputs and outputs thanks to the [debug](nodes-debug) node.
+
+![](https://github.com/melMass/comfy_mtb/assets/7041726/2b5c7e4f-372d-4494-9e73-abb2daa7cb36)
+
+- In this other example Animation Builder is used in combination with
+[Batch From History](https://github.com/melMass/comfy_mtb/wiki/nodes-batch-from-history)
+to create a zoom-in animation on a static image
+
+![](https://github.com/melMass/comfy_mtb/assets/7041726/77d37da1-0a8e-4519-a493-dfdef7f755ea)
+
+## Inputs
+
+| name | description |
+| ---- | :----------:|
+| total_frames | The number of frame to queue (this is multiplied by the `loop_count`)|
+| scale_float | Convenience input to scale the normalized `current value` (a float between 0 and 1 lerp over the current queue length) |
+| loop_count | The number of loops to queue |
+| **Reset Button** | resets the internal counters, although the node is though around using its queue button it should still work fine when using the regular queue button of comfy |
+| **Queue Button** | Convenience button to run the queues (`total_frames` * `loop_count`) |
+
+"""

    def build_animation(
        self,
@@ -41,4 +71,4 @@ class AnimationBuilder:
        return (frame, scaled, raw_loop, (frame == (total_frames - 1)))


-__nodes__ = [AnimationBuilder]
+__nodes__ = [MTB_AnimationBuilder]
@@ -0,0 +1,235 @@
+from typing import TypedDict
+
+import torch
+import torchaudio
+
+
+class AudioDict(TypedDict):
+    """Comfy's representation of AUDIO data."""
+
+    sample_rate: int
+    waveform: torch.Tensor
+
+
+AudioData = AudioDict | list[AudioDict]
+
+
+class MtbAudio:
+    """Base class for audio processing."""
+
+    @classmethod
+    def is_stereo(
+        cls,
+        audios: AudioData,
+    ) -> bool:
+        if isinstance(audios, list):
+            return any(cls.is_stereo(audio) for audio in audios)
+        else:
+            return audios["waveform"].shape[1] == 2
+
+    @staticmethod
+    def resample(audio: AudioDict, common_sample_rate: int) -> AudioDict:
+        if audio["sample_rate"] != common_sample_rate:
+            resampler = torchaudio.transforms.Resample(
+                orig_freq=audio["sample_rate"], new_freq=common_sample_rate
+            )
+            return {
+                "sample_rate": common_sample_rate,
+                "waveform": resampler(audio["waveform"]),
+            }
+        else:
+            return audio
+
+    @staticmethod
+    def to_stereo(audio: AudioDict) -> AudioDict:
+        if audio["waveform"].shape[1] == 1:
+            return {
+                "sample_rate": audio["sample_rate"],
+                "waveform": torch.cat(
+                    [audio["waveform"], audio["waveform"]], dim=1
+                ),
+            }
+        else:
+            return audio
+
+    @classmethod
+    def preprocess_audios(
+        cls, audios: list[AudioDict]
+    ) -> tuple[list[AudioDict], bool, int]:
+        max_sample_rate = max([audio["sample_rate"] for audio in audios])
+
+        resampled_audios = [
+            cls.resample(audio, max_sample_rate) for audio in audios
+        ]
+
+        is_stereo = cls.is_stereo(audios)
+        if is_stereo:
+            audios = [cls.to_stereo(audio) for audio in resampled_audios]
+
+        return (audios, is_stereo, max_sample_rate)
+
+
+class MTB_AudioCut(MtbAudio):
+    """Basic audio cutter, values are in ms."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "audio": ("AUDIO",),
+                "length": (
+                    ("FLOAT"),
+                    {
+                        "default": 1000.0,
+                        "min": 0.0,
+                        "max": 999999.0,
+                        "step": 1,
+                    },
+                ),
+                "offset": (
+                    ("FLOAT"),
+                    {"default": 0.0, "min": 0.0, "max": 999999.0, "step": 1},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("AUDIO",)
+    RETURN_NAMES = ("cut_audio",)
+    CATEGORY = "mtb/audio"
+    FUNCTION = "cut"
+
+    def cut(self, audio: AudioDict, length: float, offset: float):
+        sample_rate = audio["sample_rate"]
+        start_idx = int(offset * sample_rate / 1000)
+        end_idx = min(
+            start_idx + int(length * sample_rate / 1000),
+            audio["waveform"].shape[-1],
+        )
+        cut_waveform = audio["waveform"][:, :, start_idx:end_idx]
+
+        return (
+            {
+                "sample_rate": sample_rate,
+                "waveform": cut_waveform,
+            },
+        )
+
+
+class MTB_AudioStack(MtbAudio):
+    """Stack/Overlay audio inputs (dynamic inputs).
+
+    - pad audios to the longest inputs.
+    - resample audios to the highest sample rate in the inputs.
+    - convert them all to stereo if one of the inputs is.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {}}
+
+    RETURN_TYPES = ("AUDIO",)
+    RETURN_NAMES = ("stacked_audio",)
+    CATEGORY = "mtb/audio"
+    FUNCTION = "stack"
+
+    def stack(self, **kwargs: AudioDict) -> tuple[AudioDict]:
+        audios, is_stereo, max_rate = self.preprocess_audios(
+            list(kwargs.values())
+        )
+
+        max_length = max([audio["waveform"].shape[-1] for audio in audios])
+
+        padded_audios: list[torch.Tensor] = []
+        for audio in audios:
+            padding = torch.zeros(
+                (
+                    1,
+                    2 if is_stereo else 1,
+                    max_length - audio["waveform"].shape[-1],
+                )
+            )
+            padded_audio = torch.cat([audio["waveform"], padding], dim=-1)
+            padded_audios.append(padded_audio)
+
+        stacked_waveform = torch.stack(padded_audios, dim=0).sum(dim=0)
+
+        return (
+            {
+                "sample_rate": max_rate,
+                "waveform": stacked_waveform,
+            },
+        )
+
+
+class MTB_AudioSequence(MtbAudio):
+    """Sequence audio inputs (dynamic inputs).
+
+    - adding silence_duration between each segment
+      can now also be negative to overlap the clips, safely bound
+      to the the input length.
+    - resample audios to the highest sample rate in the inputs.
+    - convert them all to stereo if one of the inputs is.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "silence_duration": (
+                    ("FLOAT"),
+                    {"default": 0.0, "min": -999.0, "max": 999, "step": 0.01},
+                )
+            },
+        }
+
+    RETURN_TYPES = ("AUDIO",)
+    RETURN_NAMES = ("sequenced_audio",)
+    CATEGORY = "mtb/audio"
+    FUNCTION = "sequence"
+
+    def sequence(self, silence_duration: float, **kwargs: AudioDict):
+        audios, is_stereo, max_rate = self.preprocess_audios(
+            list(kwargs.values())
+        )
+
+        sequence: list[torch.Tensor] = []
+        for i, audio in enumerate(audios):
+            if i > 0:
+                if silence_duration > 0:
+                    silence = torch.zeros(
+                        (
+                            1,
+                            2 if is_stereo else 1,
+                            int(silence_duration * max_rate),
+                        )
+                    )
+                    sequence.append(silence)
+                elif silence_duration < 0:
+                    overlap = int(abs(silence_duration) * max_rate)
+                    previous_audio = sequence[-1]
+                    overlap = min(
+                        overlap,
+                        previous_audio.shape[-1],
+                        audio["waveform"].shape[-1],
+                    )
+                    if overlap > 0:
+                        overlap_part = (
+                            previous_audio[:, :, -overlap:]
+                            + audio["waveform"][:, :, :overlap]
+                        )
+                        sequence[-1] = previous_audio[:, :, :-overlap]
+                        sequence.append(overlap_part)
+                        audio["waveform"] = audio["waveform"][:, :, overlap:]
+
+            sequence.append(audio["waveform"])
+
+        sequenced_waveform = torch.cat(sequence, dim=-1)
+        return (
+            {
+                "sample_rate": max_rate,
+                "waveform": sequenced_waveform,
+            },
+        )
+
+
+__nodes__ = [MTB_AudioSequence, MTB_AudioStack, MTB_AudioCut]
@@ -6,11 +6,11 @@ import torch
 from PIL import Image

 from ..log import log
-from ..utils import apply_easing, pil2tensor
-from .transform import TransformImage
+from ..utils import EASINGS, apply_easing, pil2tensor
+from .transform import MTB_TransformImage


-def hex_to_rgb(hex_color, bgr=False):
+def hex_to_rgb(hex_color: str, bgr: bool = False):
    hex_color = hex_color.lstrip("#")
    if bgr:
        return tuple(int(hex_color[i : i + 2], 16) for i in (4, 2, 0))
@@ -18,7 +18,158 @@ def hex_to_rgb(hex_color, bgr=False):
    return tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))


-class BatchMake:
+class MTB_BatchFloatMath:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "reverse": ("BOOLEAN", {"default": False}),
+                "operation": (
+                    ["add", "sub", "mul", "div", "pow", "abs"],
+                    {"default": "add"},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("FLOATS",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "execute"
+
+    def execute(self, reverse: bool, operation: str, **kwargs: list[float]):
+        res: list[float] = []
+        vals = list(kwargs.values())
+
+        if reverse:
+            vals = vals[::-1]
+
+        ref_count = len(vals[0])
+        for v in vals:
+            if len(v) != ref_count:
+                raise ValueError(
+                    f"All values must have the same length (current: {len(v)}, ref: {ref_count}"
+                )
+
+        match operation:
+            case "add":
+                for i in range(ref_count):
+                    result = sum(v[i] for v in vals)
+                    res.append(result)
+            case "sub":
+                for i in range(ref_count):
+                    result = vals[0][i] - sum(v[i] for v in vals[1:])
+                    res.append(result)
+            case "mul":
+                for i in range(ref_count):
+                    result = vals[0][i] * vals[1][i]
+                    res.append(result)
+            case "div":
+                for i in range(ref_count):
+                    result = vals[0][i] / vals[1][i]
+                    res.append(result)
+            case "pow":
+                for i in range(ref_count):
+                    result: float = vals[0][i] ** vals[1][i]
+                    res.append(result)
+            case "abs":
+                for i in range(ref_count):
+                    result = abs(vals[0][i])
+                    res.append(result)
+            case _:
+                log.info(f"For now this mode ({operation}) is not implemented")
+
+        return (res,)
+
+
+class MTB_BatchFloatNormalize:
+    """Normalize the values in the list of floats"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {"floats": ("FLOATS",)},
+        }
+
+    RETURN_TYPES = ("FLOATS",)
+    RETURN_NAMES = ("normalized_floats",)
+    CATEGORY = "mtb/batch"
+    FUNCTION = "execute"
+
+    def execute(
+        self,
+        floats: list[float],
+    ):
+        min_value = min(floats)
+        max_value = max(floats)
+
+        normalized_floats = [
+            (x - min_value) / (max_value - min_value) for x in floats
+        ]
+        log.debug(f"Floats: {floats}")
+        log.debug(f"Normalized Floats: {normalized_floats}")
+
+        return (normalized_floats,)
+
+
+class MTB_BatchTimeWrap:
+    """Remap a batch using a time curve (FLOATS)"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "target_count": ("INT", {"default": 25, "min": 2}),
+                "frames": ("IMAGE",),
+                "curve": ("FLOATS",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "FLOATS")
+    RETURN_NAMES = ("image", "interpolated_floats")
+    CATEGORY = "mtb/batch"
+    FUNCTION = "execute"
+
+    def execute(
+        self, target_count: int, frames: torch.Tensor, curve: list[float]
+    ):
+        """Apply time warping to a list of video frames based on a curve."""
+        log.debug(f"Input frames shape: {frames.shape}")
+        log.debug(f"Curve: {curve}")
+
+        total_duration = sum(curve)
+
+        log.debug(f"Total duration: {total_duration}")
+
+        B, H, W, C = frames.shape
+
+        log.debug(f"Batch Size: {B}")
+
+        normalized_times = np.linspace(0, 1, target_count)
+        interpolated_curve = np.interp(
+            normalized_times, np.linspace(0, 1, len(curve)), curve
+        ).tolist()
+        log.debug(f"Interpolated curve: {interpolated_curve}")
+
+        interpolated_frame_indices = [
+            (B - 1) * value for value in interpolated_curve
+        ]
+        log.debug(f"Interpolated frame indices: {interpolated_frame_indices}")
+
+        rounded_indices = [
+            int(round(idx)) for idx in interpolated_frame_indices
+        ]
+        rounded_indices = np.clip(rounded_indices, 0, B - 1)
+
+        # Gather frames based on interpolated indices
+        warped_frames = []
+        for index in rounded_indices:
+            warped_frames.append(frames[index].unsqueeze(0))
+
+        warped_tensor = torch.cat(warped_frames, dim=0)
+        log.debug(f"Warped frames shape: {warped_tensor.shape}")
+        return (warped_tensor, interpolated_curve)
+
+
+class MTB_BatchMake:
    """Simply duplicates the input frame as a batch"""

    @classmethod
@@ -41,7 +192,7 @@ class BatchMake:
        return (image.repeat(count, 1, 1, 1),)


-class BatchShape:
+class MTB_BatchShape:
    """Generates a batch of 2D shapes with optional shading (experimental)"""

    @classmethod
@@ -50,8 +201,8 @@ class BatchShape:
            "required": {
                "count": ("INT", {"default": 1}),
                "shape": (
-                    ["Box", "Circle", "Diamond"],
-                    {"default": "Box"},
+                    ["Box", "Circle", "Diamond", "Tube"],
+                    {"default": "Circle"},
                ),
                "image_width": ("INT", {"default": 512}),
                "image_height": ("INT", {"default": 512}),
@@ -59,6 +210,7 @@ class BatchShape:
                "color": ("COLOR", {"default": "#ffffff"}),
                "bg_color": ("COLOR", {"default": "#000000"}),
                "shade_color": ("COLOR", {"default": "#000000"}),
+                "thickness": ("INT", {"default": 5}),
                "shadex": ("FLOAT", {"default": 0.0}),
                "shadey": ("FLOAT", {"default": 0.0}),
            },
@@ -78,12 +230,13 @@ class BatchShape:
        color,
        bg_color,
        shade_color,
+        thickness,
        shadex,
        shadey,
    ):
-        print(f"COLOR: {color}")
-        print(f"BG_COLOR: {bg_color}")
-        print(f"SHADE_COLOR: {shade_color}")
+        log.debug(f"COLOR: {color}")
+        log.debug(f"BG_COLOR: {bg_color}")
+        log.debug(f"SHADE_COLOR: {shade_color}")

        # Parse color input to BGR tuple for OpenCV
        color = hex_to_rgb(color)
@@ -118,6 +271,18 @@ class BatchShape:
                )
                cv2.fillPoly(mask, [pts], 255)

+            elif shape == "Tube":
+                cv2.ellipse(
+                    mask,
+                    center,
+                    (shape_size // 2, shape_size // 2),
+                    0,
+                    0,
+                    360,
+                    255,
+                    thickness,
+                )
+
            # Color the shape
            canvas[mask == 255] = color

@@ -138,7 +303,7 @@ class BatchShape:
        return (pil2tensor(res),)


-class BatchFloatFill:
+class MTB_BatchFloatFill:
    """Fills a batch float with a single value until it reaches the target length"""

    @classmethod
@@ -171,30 +336,33 @@ class BatchFloatFill:
        return (floats,)


-class BatchFloatAssemble:
+class MTB_BatchFloatAssemble:
    """Assembles mutiple batches of floats into a single stream (batch)"""

    @classmethod
    def INPUT_TYPES(cls):
        return {"required": {"reverse": ("BOOLEAN", {"default": False})}}

-    FUNCTION = "assemble_floats"
    RETURN_TYPES = ("FLOATS",)
    CATEGORY = "mtb/batch"
+    FUNCTION = "assemble_floats"
+
+    def assemble_floats(self, reverse: bool, **kwargs: list[float]):
+        res: list[float] = []

-    def assemble_floats(self, reverse, **kwargs):
-        res = []
        if reverse:
            for x in reversed(kwargs.values()):
-                res += x
+                if x:
+                    res += x
        else:
            for x in kwargs.values():
-                res += x
+                if x:
+                    res += x

        return (res,)


-class BatchFloat:
+class MTB_BatchFloat:
    """Generates a batch of float values with interpolation"""

    @classmethod
@@ -205,9 +373,9 @@ class BatchFloat:
                    ["Single", "Steps"],
                    {"default": "Steps"},
                ),
-                "count": ("INT", {"default": 1}),
-                "min": ("FLOAT", {"default": 0.0}),
-                "max": ("FLOAT", {"default": 1.0}),
+                "count": ("INT", {"default": 2}),
+                "min": ("FLOAT", {"default": 0.0, "step": 0.001}),
+                "max": ("FLOAT", {"default": 1.0, "step": 0.001}),
                "easing": (
                    [
                        "Linear",
@@ -243,6 +411,10 @@ class BatchFloat:
    CATEGORY = "mtb/batch"

    def set_floats(self, mode, count, min, max, easing):
+        if mode == "Steps" and count == 1:
+            raise ValueError(
+                "Steps mode requires at least a count of 2 values"
+            )
        keyframes = []
        if mode == "Single":
            keyframes = [min] * count
@@ -257,7 +429,7 @@ class BatchFloat:
        return (keyframes,)


-class BatchMerge:
+class MTB_BatchMerge:
    """Merges multiple image batches with different frame counts"""

    @classmethod
@@ -276,7 +448,7 @@ class BatchMerge:
    FUNCTION = "merge_batches"
    CATEGORY = "mtb/batch"

-    def merge_batches(self, fusion_mode, fill, **kwargs):
+    def merge_batches(self, fusion_mode: str, fill: str, **kwargs):
        images = kwargs.values()
        max_frames = max(img.shape[0] for img in images)

@@ -313,7 +485,7 @@ class BatchMerge:
        return (merged_image,)


-class Batch2dTransform:
+class MTB_Batch2dTransform:
    """Transform a batch of images using a batch of keyframes"""

    @classmethod
@@ -340,9 +512,12 @@ class Batch2dTransform:
    FUNCTION = "transform_batch"
    CATEGORY = "mtb/batch"

-    def get_num_elements(self, param) -> int:
+    def get_num_elements(
+        self, param: None | torch.Tensor | list[torch.Tensor] | list[float]
+    ) -> int:
        if isinstance(param, torch.Tensor):
            return torch.numel(param)
+
        elif isinstance(param, list):
            return len(param)

@@ -351,13 +526,13 @@ class Batch2dTransform:
    def transform_batch(
        self,
        image: torch.Tensor,
-        border_handling,
-        constant_color,
-        x=None,
-        y=None,
-        zoom=None,
-        angle=None,
-        shear=None,
+        border_handling: str,
+        constant_color: str,
+        x: list[float] | None = None,
+        y: list[float] | None = None,
+        zoom: list[float] | None = None,
+        angle: list[float] | None = None,
+        shear: list[float] | None = None,
    ):
        if all(
            self.get_num_elements(param) <= 0
@@ -367,19 +542,26 @@ class Batch2dTransform:
                "At least one transform parameter must be provided"
            )

-        keyframes = {"x": [], "y": [], "zoom": [], "angle": [], "shear": []}
+        keyframes: dict[str, list[float]] = {
+            "x": [],
+            "y": [],
+            "zoom": [],
+            "angle": [],
+            "shear": [],
+        }

        default_vals = {"x": 0, "y": 0, "zoom": 1.0, "angle": 0, "shear": 0}

-        if self.get_num_elements(x) > 0:
+        if x and self.get_num_elements(x) > 0:
            keyframes["x"] = x
-        if self.get_num_elements(y) > 0:
+        if y and self.get_num_elements(y) > 0:
            keyframes["y"] = y
-        if self.get_num_elements(zoom) > 0:
-            keyframes["zoom"] = zoom
-        if self.get_num_elements(angle) > 0:
+        if zoom and self.get_num_elements(zoom) > 0:
+            # some easing types like elastic can pull back... maybe it should abs the value?
+            keyframes["zoom"] = [max(x, 0.00001) for x in zoom]
+        if angle and self.get_num_elements(angle) > 0:
            keyframes["angle"] = angle
-        if self.get_num_elements(shear) > 0:
+        if shear and self.get_num_elements(shear) > 0:
            keyframes["shear"] = shear

        for name, values in keyframes.items():
@@ -391,7 +573,7 @@ class Batch2dTransform:
            if count == 0:
                keyframes[name] = [default_vals[name]] * image.shape[0]

-        transformer = TransformImage()
+        transformer = MTB_TransformImage()
        res = [
            transformer.transform(
                image[i].unsqueeze(0),
@@ -408,7 +590,67 @@ class Batch2dTransform:
        return (torch.cat(res, dim=0),)


-class PlotBatchFloat:
+class MTB_BatchFloatFit:
+    """Fit a list of floats using a source and target range"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "values": ("FLOATS", {"forceInput": True}),
+                "clamp": ("BOOLEAN", {"default": False}),
+                "auto_compute_source": ("BOOLEAN", {"default": False}),
+                "source_min": ("FLOAT", {"default": 0.0, "step": 0.01}),
+                "source_max": ("FLOAT", {"default": 1.0, "step": 0.01}),
+                "target_min": ("FLOAT", {"default": 0.0, "step": 0.01}),
+                "target_max": ("FLOAT", {"default": 1.0, "step": 0.01}),
+                "easing": (
+                    EASINGS,
+                    {"default": "Linear"},
+                ),
+            }
+        }
+
+    FUNCTION = "fit_range"
+    RETURN_TYPES = ("FLOATS",)
+    CATEGORY = "mtb/batch"
+    DESCRIPTION = "Fit a list of floats using a source and target range"
+
+    def fit_range(
+        self,
+        values: list[float],
+        clamp: bool,
+        auto_compute_source: bool,
+        source_min: float,
+        source_max: float,
+        target_min: float,
+        target_max: float,
+        easing: str,
+    ):
+        if auto_compute_source:
+            source_min = min(values)
+            source_max = max(values)
+
+        from .graph_utils import MTB_FitNumber
+
+        res = []
+        fit_number = MTB_FitNumber()
+        for value in values:
+            (transformed_value,) = fit_number.set_range(
+                value,
+                clamp,
+                source_min,
+                source_max,
+                target_min,
+                target_max,
+                easing,
+            )
+            res.append(transformed_value)
+
+        return (res,)
+
+
+class MTB_PlotBatchFloat:
    """Plot floats"""

    @classmethod
@@ -419,6 +661,7 @@ class PlotBatchFloat:
                "height": ("INT", {"default": 768}),
                "point_size": ("INT", {"default": 4}),
                "seed": ("INT", {"default": 1}),
+                "start_at_zero": ("BOOLEAN", {"default": False}),
            }
        }

@@ -427,10 +670,21 @@ class PlotBatchFloat:
    FUNCTION = "plot"
    CATEGORY = "mtb/batch"

-    def plot(self, width, height, point_size, seed, **kwargs):
+    def plot(
+        self,
+        width: int,
+        height: int,
+        point_size: int,
+        seed: int,
+        start_at_zero: bool,
+        interactive_backend: bool = False,
+        **kwargs,
+    ):
        import matplotlib

-        matplotlib.use("Agg")
+        # NOTE: This is for notebook usage or tests, i.e not exposed to comfy that should always use Agg
+        if not interactive_backend:
+            matplotlib.use("Agg")
        import matplotlib.pyplot as plt

        fig, ax = plt.subplots(figsize=(width / 100, height / 100), dpi=100)
@@ -441,26 +695,30 @@ class PlotBatchFloat:
        ax.grid(color="gray", linestyle="-", linewidth=0.5, alpha=0.5)

        # Finding global min and max across all lists for scaling the plot
-        global_min = min(min(values) for values in kwargs.values())
-        global_max = max(max(values) for values in kwargs.values())
+        all_values = [value for values in kwargs.values() for value in values]
+        global_min = min(all_values)
+        global_max = max(all_values)

-        # Color cycle to ensure each plot has a distinct color
-        colormap = plt.cm.get_cmap("viridis", len(kwargs))
-        color_normalization_factor = (
-            0.5 if len(kwargs) == 1 else (len(kwargs) - 1)
-        )
+        y_padding = 0.05 * (global_max - global_min)
+        ax.set_ylim(global_min - y_padding, global_max + y_padding)

-        # Plotting each list with a unique color
-        for i, (label, values) in enumerate(kwargs.items()):
-            color_value = i / color_normalization_factor
-            ax.plot(values, label=label, color=colormap(color_value))
+        max_length = max(len(values) for values in kwargs.values())
+        if start_at_zero:
+            x_values = np.linspace(0, max_length - 1, max_length)
+        else:
+            x_values = np.linspace(1, max_length, max_length)

-        ax.set_ylim(global_min, global_max)  # Scaling the y-axis
+        ax.set_xlim(1, max_length)  # Set X-axis limits
+        np.random.seed(seed)
+        colors = np.random.rand(len(kwargs), 3)  # Generate random RGB values
+        for color, (label, values) in zip(colors, kwargs.items()):
+            ax.plot(x_values[: len(values)], values, label=label, color=color)
        ax.legend(
            title="Legend",
            title_fontsize="large",
            fontsize="medium",
            edgecolor="black",
+            loc="best",
        )

        # Setting labels and title
@@ -543,7 +801,7 @@ class PlotBatchFloat:
 DEFAULT_INTERPOLANT = lambda t: t * t * t * (t * (t * 6 - 15) + 10)


-class BatchShake:
+class MTB_BatchShake:
    """Applies a shaking effect to batches of images."""

    @classmethod
@@ -585,10 +843,12 @@ class BatchShake:
            interpolant: The interpolation function, defaults to
                t*t*t*(t*(t*6 - 15) + 10).

-        Returns:
+        Returns
+        -------
            A numpy array of shape shape with the generated noise.

-        Raises:
+        Raises
+        ------
            ValueError: If shape is not a multiple of res.
        """
        interpolant = interpolant or DEFAULT_INTERPOLANT
@@ -651,11 +911,13 @@ class BatchShake:
            interpolant: The, interpolation function, defaults to
                t*t*t*(t*(t*6 - 15) + 10).

-        Returns:
+        Returns
+        -------
            A numpy array of fractal noise and of shape shape generated by
            combining several octaves of perlin noise.

-        Raises:
+        Raises
+        ------
            ValueError: If shape is not a multiple of
                (lacunarity**(octaves-1)*res).
        """
@@ -744,7 +1006,7 @@ class BatchShake:
        # rotations = torch.tensor(rotations, dtype=torch.float32)

        # Create an instance of Batch2dTransform
-        transform = Batch2dTransform()
+        transform = MTB_Batch2dTransform()

        log.debug(
            f"Applying shaking with parameters: \nposition {position_amount_x}, {position_amount_y}\nrotation {rotation_amount}\nfrequency {frequency}\noctaves {octaves}"
@@ -764,13 +1026,17 @@ class BatchShake:


 __nodes__ = [
-    BatchFloat,
-    Batch2dTransform,
-    BatchShape,
-    BatchMake,
-    BatchFloatAssemble,
-    BatchFloatFill,
-    BatchMerge,
-    BatchShake,
-    PlotBatchFloat,
+    MTB_BatchFloat,
+    MTB_Batch2dTransform,
+    MTB_BatchShape,
+    MTB_BatchMake,
+    MTB_BatchFloatAssemble,
+    MTB_BatchFloatFill,
+    MTB_BatchFloatNormalize,
+    MTB_BatchMerge,
+    MTB_BatchShake,
+    MTB_PlotBatchFloat,
+    MTB_BatchTimeWrap,
+    MTB_BatchFloatFit,
+    MTB_BatchFloatMath,
 ]
@@ -1,4 +1,5 @@
-import csv, shutil
+import csv
+import shutil
 from pathlib import Path

 import folder_paths
@@ -7,7 +8,7 @@ from ..log import log
 from ..utils import here


-class InterpolateClipSequential:
+class MTB_InterpolateClipSequential:
    @classmethod
    def INPUT_TYPES(cls):
        return {
@@ -28,7 +29,12 @@ class InterpolateClipSequential:
    CATEGORY = "mtb/conditioning"

    def interpolate_encodings_sequential(
-        self, base_text, text_to_replace, clip, interpolation_strength, **replacements
+        self,
+        base_text,
+        text_to_replace,
+        clip,
+        interpolation_strength,
+        **replacements,
    ):
        log.debug(f"Received interpolation_strength: {interpolation_strength}")

@@ -63,20 +69,30 @@ class InterpolateClipSequential:
            log.debug("Using the base text a the base blend")
            # -  Start with the base_text condition
            tokens = clip.tokenize(base_text)
-            cond_from, pooled_from = clip.encode_from_tokens(tokens, return_pooled=True)
+            cond_from, pooled_from = clip.encode_from_tokens(
+                tokens, return_pooled=True
+            )
        else:
            base_replace = list(replacements.values())[segment_index - 1]
            log.debug(f"Using {base_replace} a the base blend")

            # - Start with the base_text condition replaced by the closest replacement
-            tokens = clip.tokenize(base_text.replace(text_to_replace, base_replace))
-            cond_from, pooled_from = clip.encode_from_tokens(tokens, return_pooled=True)
+            tokens = clip.tokenize(
+                base_text.replace(text_to_replace, base_replace)
+            )
+            cond_from, pooled_from = clip.encode_from_tokens(
+                tokens, return_pooled=True
+            )

            replacement_text = list(replacements.values())[segment_index]

-        interpolated_text = base_text.replace(text_to_replace, replacement_text)
+        interpolated_text = base_text.replace(
+            text_to_replace, replacement_text
+        )
        tokens = clip.tokenize(interpolated_text)
-        cond_to, pooled_to = clip.encode_from_tokens(tokens, return_pooled=True)
+        cond_to, pooled_to = clip.encode_from_tokens(
+            tokens, return_pooled=True
+        )

        # - Linearly interpolate between the two conditions
        interpolated_condition = (
@@ -86,10 +102,12 @@ class InterpolateClipSequential:
            1.0 - local_strength
        ) * pooled_from + local_strength * pooled_to

-        return ([[interpolated_condition, {"pooled_output": interpolated_pooled}]],)
+        return (
+            [[interpolated_condition, {"pooled_output": interpolated_pooled}]],
+        )


-class SmartStep:
+class MTB_SmartStep:
    """Utils to control the steps start/stop of the KAdvancedSampler in percentage"""

    @classmethod
@@ -136,7 +154,7 @@ def install_default_styles(force=False):
    return dest_style


-class StylesLoader:
+class MTB_StylesLoader:
    """Load csv files and populate a dropdown from the rows (à la A111)"""

    options = {}
@@ -148,16 +166,18 @@ class StylesLoader:
            if not input_dir.exists():
                install_default_styles()

-            if not (files := [f for f in input_dir.iterdir() if f.suffix == ".csv"]):
+            if not (
+                files := [f for f in input_dir.iterdir() if f.suffix == ".csv"]
+            ):
                log.warn(
                    "No styles found in the styles folder, place at least one csv file in the styles folder at the root of ComfyUI (for instance ComfyUI/styles/mystyle.csv)"
                )

            for file in files:
-                with open(file, "r", encoding="utf8") as f:
+                with open(file, encoding="utf8") as f:
                    parsed = csv.reader(f)
                    for i, row in enumerate(parsed):
-                        log.debug(f"Adding style {row[0]}")
+                        # log.debug(f"Adding style {row[0]}")
                        try:
                            name, positive, negative = (row + [None] * 3)[:3]
                            positive = positive or ""
@@ -193,4 +213,4 @@ class StylesLoader:
        return (self.options[style_name][0], self.options[style_name][1])


-__nodes__ = [SmartStep, StylesLoader, InterpolateClipSequential]
+__nodes__ = [MTB_SmartStep, MTB_StylesLoader, MTB_InterpolateClipSequential]
@@ -0,0 +1,27 @@
+import json
+
+from ..log import log
+
+
+class MTB_Constant:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {"Value": ("*",)},
+        }
+
+    RETURN_TYPES = ("*",)
+    RETURN_NAMES = ("output",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "execute"
+
+    def execute(
+        self,
+        **kwargs,
+    ):
+        log.debug("Received kwargs")
+        log.debug(json.dumps(kwargs, check_circular=True))
+        return (kwargs.get("Value"),)
+
+
+# __nodes__ = [MTB_Constant]
@@ -1,12 +1,12 @@
 import numpy as np
 import torch
-from PIL import Image, ImageChops, ImageDraw, ImageFilter
+from PIL import Image, ImageDraw, ImageFilter

 from ..log import log
 from ..utils import np2tensor, pil2tensor, tensor2np, tensor2pil


-class Bbox:
+class MTB_Bbox:
    """The bounding box (BBOX) custom type used by other nodes"""

    @classmethod
@@ -14,8 +14,14 @@ class Bbox:
        return {
            "required": {
                # "bbox": ("BBOX",),
-                "x": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
-                "y": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
+                "x": (
+                    "INT",
+                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
+                ),
+                "y": (
+                    "INT",
+                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
+                ),
                "width": (
                    "INT",
                    {"default": 256, "max": 10000000, "min": 0, "step": 1},
@@ -31,12 +37,29 @@ class Bbox:
    FUNCTION = "do_crop"
    CATEGORY = "mtb/crop"

-    def do_crop(self, x, y, width, height):  # bbox
+    def do_crop(self, x: int, y: int, width: int, height: int):  # bbox
        return ((x, y, width, height),)
-        # return bbox


-class BboxFromMask:
+class MTB_SplitBbox:
+    """Split the components of a bbox"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {"bbox": ("BBOX",)},
+        }
+
+    CATEGORY = "mtb/crop"
+    FUNCTION = "split_bbox"
+    RETURN_TYPES = ("INT", "INT", "INT", "INT")
+    RETURN_NAMES = ("x", "y", "width", "height")
+
+    def split_bbox(self, bbox):
+        return (bbox[0], bbox[1], bbox[2], bbox[3])
+
+
+class MTB_BboxFromMask:
    """From a mask extract the bounding box"""

    @classmethod
@@ -62,7 +85,9 @@ class BboxFromMask:
    FUNCTION = "extract_bounding_box"
    CATEGORY = "mtb/crop"

-    def extract_bounding_box(self, mask: torch.Tensor, invert: bool, image=None):
+    def extract_bounding_box(
+        self, mask: torch.Tensor, invert: bool, image=None
+    ):
        # if image != None:
        #     if mask.size(0) != image.size(0):
        #         if mask.size(0) != 1:
@@ -103,7 +128,7 @@ class BboxFromMask:
        )


-class Crop:
+class MTB_Crop:
    """Crops an image and an optional mask to a given bounding box

    The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type
@@ -118,8 +143,14 @@ class Crop:
            },
            "optional": {
                "mask": ("MASK",),
-                "x": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
-                "y": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
+                "x": (
+                    "INT",
+                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
+                ),
+                "y": (
+                    "INT",
+                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
+                ),
                "width": (
                    "INT",
                    {"default": 256, "max": 10000000, "min": 0, "step": 1},
@@ -138,7 +169,14 @@ class Crop:
    CATEGORY = "mtb/crop"

    def do_crop(
-        self, image: torch.Tensor, mask=None, x=0, y=0, width=256, height=256, bbox=None
+        self,
+        image: torch.Tensor,
+        mask=None,
+        x=0,
+        y=0,
+        width=256,
+        height=256,
+        bbox=None,
    ):
        image = image.numpy()
        if mask is not None:
@@ -151,13 +189,17 @@ class Crop:
        cropped_mask = None
        if mask is not None:
            cropped_mask = (
-                mask[:, y : y + height, x : x + width] if mask is not None else None
+                mask[:, y : y + height, x : x + width]
+                if mask is not None
+                else None
            )
        crop_data = (x, y, width, height)

        return (
            torch.from_numpy(cropped_image),
-            torch.from_numpy(cropped_mask) if cropped_mask is not None else None,
+            torch.from_numpy(cropped_mask)
+            if cropped_mask is not None
+            else None,
            crop_data,
        )

@@ -194,11 +236,12 @@ def bbox_to_region(bbox, target_size=None):
    return (bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3])


-class Uncrop:
+class MTB_Uncrop:
    """Uncrops an image to a given bounding box

    The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type
-    The BBOX input takes precedence over the tuple input"""
+    The BBOX input takes precedence over the tuple input
+    """

    @classmethod
    def INPUT_TYPES(cls):
@@ -222,11 +265,15 @@ class Uncrop:
    def do_crop(self, image, crop_image, bbox, border_blending):
        def inset_border(image, border_width=20, border_color=(0)):
            width, height = image.size
-            bordered_image = Image.new(image.mode, (width, height), border_color)
+            bordered_image = Image.new(
+                image.mode, (width, height), border_color
+            )
            bordered_image.paste(image, (0, 0))
            draw = ImageDraw.Draw(bordered_image)
            draw.rectangle(
-                (0, 0, width - 1, height - 1), outline=border_color, width=border_width
+                (0, 0, width - 1, height - 1),
+                outline=border_color,
+                width=border_width,
            )
            return bordered_image

@@ -249,7 +296,9 @@ class Uncrop:
            # uncrop the image based on the bounding box
            bb_x, bb_y, bb_width, bb_height = bbox

-            paste_region = bbox_to_region((bb_x, bb_y, bb_width, bb_height), img.size)
+            paste_region = bbox_to_region(
+                (bb_x, bb_y, bb_width, bb_height), img.size
+            )
            # log.debug(f"Paste region: {paste_region}")
            # new_region = adjust_paste_region(img.size, paste_region)
            # log.debug(f"Adjusted paste region: {new_region}")
@@ -275,12 +324,16 @@ class Uncrop:

            mask.paste(mask_block, paste_region)
            log.debug(f"Blend size: {blend.size} | kind {blend.mode}")
-            log.debug(f"Crop image size: {crop_img.size} | kind {crop_img.mode}")
+            log.debug(
+                f"Crop image size: {crop_img.size} | kind {crop_img.mode}"
+            )
            log.debug(f"BBox: {paste_region}")
            blend.paste(crop_img, paste_region)

            mask = mask.filter(ImageFilter.BoxBlur(radius=blend_ratio / 4))
-            mask = mask.filter(ImageFilter.GaussianBlur(radius=blend_ratio / 4))
+            mask = mask.filter(
+                ImageFilter.GaussianBlur(radius=blend_ratio / 4)
+            )

            blend.putalpha(mask)
            img = Image.alpha_composite(img.convert("RGBA"), blend)
@@ -289,4 +342,4 @@ class Uncrop:
        return (pil2tensor(out_images),)


-__nodes__ = [BboxFromMask, Bbox, Crop, Uncrop]
+__nodes__ = [MTB_BboxFromMask, MTB_Bbox, MTB_Crop, MTB_Uncrop, MTB_SplitBbox]
@@ -1,5 +1,7 @@
 import json

+from ..log import log
+

 def deserialize_curve(curve):
    if isinstance(curve, str):
@@ -30,7 +32,62 @@ class MTB_Curve:
    CATEGORY = "mtb/curve"

    def do_curve(self, curve):
+        log.debug(f"Curve: {curve}")
        return (curve,)


-__nodes__ = [MTB_Curve]
+class MTB_CurveToFloat:
+    """Convert a FLOAT_CURVE to a FLOAT or FLOATS"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "curve": ("FLOAT_CURVE", {"forceInput": True}),
+                "steps": ("INT", {"default": 10, "min": 2}),
+            },
+        }
+
+    RETURN_TYPES = ("FLOATS", "FLOAT")
+    FUNCTION = "do_curve"
+
+    CATEGORY = "mtb/curve"
+
+    def do_curve(self, curve, steps):
+        log.debug(f"Curve: {curve}")
+
+        # sort by x (should be handled by the widget)
+        sorted_points = sorted(curve.items(), key=lambda item: item[1]["x"])
+        # Extract X and Y values
+        x_values = [point[1]["x"] for point in sorted_points]
+        y_values = [point[1]["y"] for point in sorted_points]
+        # Calculate step size
+        step_size = (max(x_values) - min(x_values)) / (steps - 1)
+
+        # Interpolate Y values for each step
+        interpolated_y_values = []
+        for step in range(steps):
+            current_x = min(x_values) + step_size * step
+
+            # Find the indices of the two points between which the current_x falls
+            idx1 = max(idx for idx, x in enumerate(x_values) if x <= current_x)
+            idx2 = min(idx for idx, x in enumerate(x_values) if x >= current_x)
+
+            # If the current_x matches one of the points, no interpolation is needed
+            if current_x == x_values[idx1]:
+                interpolated_y_values.append(y_values[idx1])
+            elif current_x == x_values[idx2]:
+                interpolated_y_values.append(y_values[idx2])
+            else:
+                # Interpolate Y value using linear interpolation
+                y1 = y_values[idx1]
+                y2 = y_values[idx2]
+                x1 = x_values[idx1]
+                x2 = x_values[idx2]
+                interpolated_y = y1 + (y2 - y1) * (current_x - x1) / (x2 - x1)
+                interpolated_y_values.append(interpolated_y)
+
+        return (interpolated_y_values, interpolated_y_values)
+
+
+__nodes__ = [MTB_Curve, MTB_CurveToFloat]
@@ -1,5 +1,6 @@
 import base64
 import io
+import json
 from pathlib import Path
 from typing import Optional

@@ -47,6 +48,8 @@ def process_list(anything):
        text.append(
            f"List of Tensors: {first_element.shape} (x{len(anything)})"
        )
+    else:
+        text.append(f"Array ({len(anything)}): {anything}")

    return {"text": text}

@@ -59,6 +62,9 @@ def process_dict(anything):
        )
        text.append(f"Latent Samples: {anything['samples'].shape} {is_empty}")

+    else:
+        text.append(json.dumps(anything, indent=2))
+
    return {"text": text}


@@ -73,7 +79,7 @@ def process_text(anything):
 # endregion


-class Debug:
+class MTB_Debug:
    """Experimental node to debug any Comfy values.

    support for more types and widgets is planned.
@@ -90,7 +96,7 @@ class Debug:
    CATEGORY = "mtb/debug"
    OUTPUT_NODE = True

-    def do_debug(self, output_to_console, **kwargs):
+    def do_debug(self, output_to_console: bool, **kwargs):
        output = {
            "ui": {"b64_images": [], "text": []},
            # "result": ("A"),
@@ -103,10 +109,12 @@ class Debug:
            bool: process_bool,
        }
        if output_to_console:
-            print("bouh!")
+            for k, v in kwargs.items():
+                log.info(f"{k}: {v}")

        for anything in kwargs.values():
            processor = processors.get(type(anything), process_text)
+
            processed_data = processor(anything)

            for ui_key, ui_value in processed_data.items():
@@ -115,7 +123,7 @@ class Debug:
        return output


-class SaveTensors:
+class MTB_SaveTensors:
    """Save torch tensors (image, mask or latent) to disk.

    useful to debug things outside comfy.
@@ -180,4 +188,4 @@ class SaveTensors:
        return f"{filename_prefix}_{counter:05}"


-__nodes__ = [Debug, SaveTensors]
+__nodes__ = [MTB_Debug, MTB_SaveTensors]
@@ -69,7 +69,26 @@ def color_to_normals(
    if not model or not model.exists():
        raise ModelNotFound(f"deepbump ({model})")

-    ort_session = ort.InferenceSession(model)
+    providers = [
+        "TensorrtExecutionProvider",
+        "CUDAExecutionProvider",
+        "CoreMLProvider",
+        "CPUExecutionProvider",
+    ]
+    available_providers = [
+        provider
+        for provider in providers
+        if provider in ort.get_available_providers()
+    ]
+
+    if not available_providers:
+        raise RuntimeError(
+            "No valid ONNX Runtime providers available on this machine."
+        )
+    log.debug(f"Using ONNX providers: {available_providers}")
+    ort_session = ort.InferenceSession(
+        model.as_posix(), providers=available_providers
+    )

    # Predict normal map for each tile
    log.debug("DeepBump Color → Normals : generating")
@@ -303,7 +322,7 @@ def normals_to_height(normals_img, seamless, progress_callback):


 # - ADDON
-class DeepBump:
+class MTB_DeepBump:
    """Normal & height maps generation from single pictures"""

    @classmethod
@@ -386,4 +405,4 @@ class DeepBump:
        return (torch.cat(out_images, dim=0),)


-__nodes__ = [DeepBump]
+__nodes__ = [MTB_DeepBump]
@@ -1,6 +1,4 @@
 import os
-from pathlib import Path
-from typing import Tuple

 import comfy
 import comfy.utils
@@ -9,14 +7,13 @@ import folder_paths
 import numpy as np
 import torch
 from comfy import model_management
-from gfpgan import GFPGANer
 from PIL import Image

 from ..log import NullWriter, log
 from ..utils import get_model_path, np2tensor, pil2tensor, tensor2np


-class LoadFaceEnhanceModel:
+class MTB_LoadFaceEnhanceModel:
    """Loads a GFPGan or RestoreFormer model for face enhancement."""

    def __init__(self) -> None:
@@ -37,7 +34,9 @@ class LoadFaceEnhanceModel:
        fr_models_path, um_models_path = cls.get_models_root()

        if fr_models_path is None and um_models_path is None:
-            log.warning("Face restoration models not found.")
+            if not hasattr(cls, "_warned"):
+                log.warning("Face restoration models not found.")
+                cls._warned = True
            return []
        if not fr_models_path.exists():
            # log.warning(
@@ -81,6 +80,8 @@ class LoadFaceEnhanceModel:
    CATEGORY = "mtb/facetools"

    def load_model(self, model_name, upscale=2, bg_upsampler=None):
+        from gfpgan import GFPGANer
+
        basic = "RestoreFormer" not in model_name

        fr_root, um_root = self.get_models_root()
@@ -153,7 +154,7 @@ class BGUpscaleWrapper:
 import sys


-class RestoreFace:
+class MTB_RestoreFace:
    """Uses GFPGan to restore faces"""

    def __init__(self) -> None:
@@ -176,22 +177,33 @@ class RestoreFace:
                # Adjustable weights
                "weight": ("FLOAT", {"default": 0.5}),
                "save_tmp_steps": ("BOOLEAN", {"default": True}),
-            }
+            },
+            "optional": {
+                "preserve_alpha": ("BOOLEAN", {"default": True}),
+            },
        }

    def do_restore(
        self,
        image: torch.Tensor,
-        model: GFPGANer,
+        model,
        aligned,
        only_center_face,
        weight,
        save_tmp_steps,
+        preserve_alpha: bool = False,
    ) -> torch.Tensor:
        pimage = tensor2np(image)[0]
        width, height = pimage.shape[1], pimage.shape[0]
        source_img = cv2.cvtColor(np.array(pimage), cv2.COLOR_RGB2BGR)

+        alpha_channel = None
+        if (
+            preserve_alpha and image.size(-1) == 4
+        ):  # Check if the image has an alpha channel
+            alpha_channel = pimage[:, :, 3]
+            pimage = pimage[:, :, :3]  # Remove alpha channel for processing
+
        sys.stdout = NullWriter()
        cropped_faces, restored_faces, restored_img = model.enhance(
            source_img,
@@ -210,9 +222,14 @@ class RestoreFace:
            )
        output = None
        if restored_img is not None:
-            output = Image.fromarray(
-                cv2.cvtColor(restored_img, cv2.COLOR_BGR2RGB)
-            )
+            restored_img = cv2.cvtColor(restored_img, cv2.COLOR_BGR2RGB)
+            output = Image.fromarray(restored_img)
+
+            if alpha_channel is not None:
+                alpha_resized = Image.fromarray(alpha_channel).resize(
+                    output.size, Image.LANCZOS
+                )
+                output.putalpha(alpha_resized)
            # imwrite(restored_img, save_restore_path)

        return pil2tensor(output)
@@ -220,12 +237,13 @@ class RestoreFace:
    def restore(
        self,
        image: torch.Tensor,
-        model: GFPGANer,
+        model,
        aligned=False,
        only_center_face=False,
        weight=0.5,
        save_tmp_steps=True,
-    ) -> Tuple[torch.Tensor]:
+        preserve_alpha: bool = False,
+    ) -> tuple[torch.Tensor]:
        out = [
            self.do_restore(
                image[i],
@@ -234,6 +252,7 @@ class RestoreFace:
                only_center_face,
                weight,
                save_tmp_steps,
+                preserve_alpha,
            )
            for i in range(image.size(0))
        ]
@@ -259,7 +278,7 @@ class RestoreFace:
        self, cropped_faces, restored_faces, height, width
    ):
        for idx, (cropped_face, restored_face) in enumerate(
-            zip(cropped_faces, restored_faces)
+            zip(cropped_faces, restored_faces, strict=False)
        ):
            face_id = idx + 1
            file = self.get_step_image_path("cropped_faces", face_id)
@@ -275,4 +294,4 @@ class RestoreFace:
            cv2.imwrite(file, cmp_img)


-__nodes__ = [RestoreFace, LoadFaceEnhanceModel]
+__nodes__ = [MTB_RestoreFace, MTB_LoadFaceEnhanceModel]
@@ -2,7 +2,6 @@
 # region imports
 import sys
 from pathlib import Path
-from typing import List, Optional, Set, Union

 import comfy.model_management as model_management
 import cv2
@@ -22,7 +21,7 @@ from ..utils import download_antelopev2, get_model_path, pil2tensor, tensor2pil
 log = mklog(__name__)


-class LoadFaceAnalysisModel:
+class MTB_LoadFaceAnalysisModel:
    """Loads a face analysis model"""

    models = []
@@ -48,18 +47,21 @@ class LoadFaceAnalysisModel:

        face_analyser = insightface.app.FaceAnalysis(
            name=faceswap_model,
-            root=get_model_path("insightface"),
+            root=get_model_path("insightface").as_posix(),
        )
        return (face_analyser,)


-class LoadFaceSwapModel:
+class MTB_LoadFaceSwapModel:
    """Loads a faceswap model"""

    @staticmethod
-    def get_models() -> List[Path]:
-        models_path = get_model_path("insightface").iterdir()
-        return [x for x in models_path if x.suffix in [".onnx", ".pth"]]
+    def get_models() -> list[Path]:
+        models_path = get_model_path("insightface")
+        if models_path.exists():
+            models = models_path.iterdir()
+            return [x for x in models if x.suffix in [".onnx", ".pth"]]
+        return []

    @classmethod
    def INPUT_TYPES(cls):
@@ -94,7 +96,7 @@ class LoadFaceSwapModel:


 # region roop node
-class FaceSwap:
+class MTB_FaceSwap:
    """Face swap using deepinsight/insightface models"""

    model = None
@@ -110,10 +112,15 @@ class FaceSwap:
                "image": ("IMAGE",),
                "reference": ("IMAGE",),
                "faces_index": ("STRING", {"default": "0"}),
-                "faceanalysis_model": ("FACE_ANALYSIS_MODEL", {"default": "None"}),
+                "faceanalysis_model": (
+                    "FACE_ANALYSIS_MODEL",
+                    {"default": "None"},
+                ),
                "faceswap_model": ("FACESWAP_MODEL", {"default": "None"}),
            },
-            "optional": {},
+            "optional": {
+                "preserve_alpha": ("BOOLEAN", {"default": True}),
+            },
        }

    RETURN_TYPES = ("IMAGE",)
@@ -127,17 +134,30 @@ class FaceSwap:
        faces_index: str,
        faceanalysis_model,
        faceswap_model,
+        preserve_alpha=False,
    ):
        def do_swap(img):
            model_management.throw_exception_if_processing_interrupted()
            img = tensor2pil(img)[0]
            ref = tensor2pil(reference)[0]
+
+            alpha_channel = None
+            if preserve_alpha and img.mode == "RGBA":
+                alpha_channel = img.getchannel("A")
+                img = img.convert("RGB")
+
            face_ids = {
-                int(x) for x in faces_index.strip(",").split(",") if x.isnumeric()
+                int(x)
+                for x in faces_index.strip(",").split(",")
+                if x.isnumeric()
            }
            sys.stdout = NullWriter()
-            swapped = swap_face(faceanalysis_model, ref, img, faceswap_model, face_ids)
+            swapped = swap_face(
+                faceanalysis_model, ref, img, faceswap_model, face_ids
+            )
            sys.stdout = sys.__stdout__
+            if alpha_channel:
+                swapped.putalpha(alpha_channel)
            return pil2tensor(swapped)

        batch_count = image.size(0)
@@ -170,7 +190,10 @@ def get_face_single(
        log.debug("No face ed, trying again with smaller image")
        det_size_half = (det_size[0] // 2, det_size[1] // 2)
        return get_face_single(
-            face_analyser, img_data, face_index=face_index, det_size=det_size_half
+            face_analyser,
+            img_data,
+            face_index=face_index,
+            det_size=det_size_half,
        )

    try:
@@ -181,10 +204,10 @@ def get_face_single(

 def swap_face(
    face_analyser,
-    source_img: Union[Image.Image, List[Image.Image]],
-    target_img: Union[Image.Image, List[Image.Image]],
+    source_img: Image.Image | list[Image.Image],
+    target_img: Image.Image | list[Image.Image],
    face_swapper_model,
-    faces_index: Optional[Set[int]] = None,
+    faces_index: set[int] | None = None,
 ) -> Image.Image:
    if faces_index is None:
        faces_index = {0}
@@ -194,7 +217,9 @@ def swap_face(
    if face_swapper_model is not None:
        cv_source_img = cv2.cvtColor(np.array(source_img), cv2.COLOR_RGB2BGR)
        cv_target_img = cv2.cvtColor(np.array(target_img), cv2.COLOR_RGB2BGR)
-        source_face = get_face_single(face_analyser, cv_source_img, face_index=0)
+        source_face = get_face_single(
+            face_analyser, cv_source_img, face_index=0
+        )
        if source_face is not None:
            result = cv_target_img

@@ -204,12 +229,16 @@ def swap_face(
                )
                if target_face is not None:
                    sys.stdout = NullWriter()
-                    result = face_swapper_model.get(result, target_face, source_face)
+                    result = face_swapper_model.get(
+                        result, target_face, source_face
+                    )
                    sys.stdout = sys.__stdout__
                else:
                    log.warning(f"No target face found for {face_num}")

-            result_image = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
+            result_image = Image.fromarray(
+                cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
+            )
        else:
            log.warning("No source face found")
    else:
@@ -220,4 +249,4 @@ def swap_face(
 # endregion face swap utils


-__nodes__ = [FaceSwap, LoadFaceSwapModel, LoadFaceAnalysisModel]
+__nodes__ = [MTB_FaceSwap, MTB_LoadFaceSwapModel, MTB_LoadFaceAnalysisModel]
@@ -1,4 +1,3 @@
-import qrcode
 from PIL import Image

 from ..log import log
@@ -52,7 +51,7 @@ from ..utils import comfy_dir, font_path, pil2tensor
 #         return m.digest().hex()


-class UnsplashImage:
+class MTB_UnsplashImage:
    """Unsplash Image given a keyword and a size"""

    @classmethod
@@ -113,76 +112,6 @@ class UnsplashImage:
            return (None,)


-class QrCode:
-    """Basic QR Code generator"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "url": ("STRING", {"default": "https://www.github.com"}),
-                "width": (
-                    "INT",
-                    {"default": 256, "max": 8096, "min": 0, "step": 1},
-                ),
-                "height": (
-                    "INT",
-                    {"default": 256, "max": 8096, "min": 0, "step": 1},
-                ),
-                "error_correct": (("L", "M", "Q", "H"), {"default": "L"}),
-                "box_size": (
-                    "INT",
-                    {"default": 10, "max": 8096, "min": 0, "step": 1},
-                ),
-                "border": (
-                    "INT",
-                    {"default": 4, "max": 8096, "min": 0, "step": 1},
-                ),
-                "invert": (("BOOLEAN",), {"default": False}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "do_qr"
-    CATEGORY = "mtb/generate"
-
-    def do_qr(
-        self, url, width, height, error_correct, box_size, border, invert
-    ):
-        log.warning(
-            "This node will soon be deprecated, there are much better alternatives like https://github.com/coreyryanhanson/comfy-qr"
-        )
-        if error_correct == "L" or error_correct not in ["M", "Q", "H"]:
-            error_correct = qrcode.constants.ERROR_CORRECT_L
-        elif error_correct == "M":
-            error_correct = qrcode.constants.ERROR_CORRECT_M
-        elif error_correct == "Q":
-            error_correct = qrcode.constants.ERROR_CORRECT_Q
-        else:
-            error_correct = qrcode.constants.ERROR_CORRECT_H
-
-        qr = qrcode.QRCode(
-            version=1,
-            error_correction=error_correct,
-            box_size=box_size,
-            border=border,
-        )
-        qr.add_data(url)
-        qr.make(fit=True)
-
-        back_color = (255, 255, 255) if invert else (0, 0, 0)
-        fill_color = (0, 0, 0) if invert else (255, 255, 255)
-
-        code = img = qr.make_image(
-            back_color=back_color, fill_color=fill_color
-        )
-
-        # that we now resize without filtering
-        code = code.resize((width, height), Image.NEAREST)
-
-        return (pil2tensor(code),)
-
-
 def bbox_dim(bbox):
    left, upper, right, lower = bbox
    width = right - left
@@ -193,13 +122,20 @@ def bbox_dim(bbox):
 # TODO: Auto install the base font to ComfyUI/fonts


-class TextToImage:
+class MTB_TextToImage:
    """Utils to convert text to image using a font.

    The tool looks for any .ttf file in the Comfy folder hierarchy.
    """

    fonts = {}
+    DESCRIPTION = """# Text to Image
+
+This node look for any font files in comfy_dir/fonts.
+by default it fallsback to a default font.
+
+![img](https://i.imgur.com/3GT92hy.gif)
+"""

    def __init__(self):
        # - This is executed when the graph is executed,
@@ -222,7 +158,7 @@ class TextToImage:

        for font in fonts:
            log.debug(f"Adding font {font}")
-            TextToImage.fonts[font.stem] = font.as_posix()
+            MTB_TextToImage.fonts[font.stem] = font.as_posix()

    @classmethod
    def INPUT_TYPES(cls):
@@ -357,8 +293,7 @@ class TextToImage:


 __nodes__ = [
-    QrCode,
-    UnsplashImage,
-    TextToImage,
+    MTB_UnsplashImage,
+    MTB_TextToImage,
    #  MtbExamples,
 ]
@@ -1,12 +1,24 @@
-from typing import Optional
-import io, json, urllib.parse, urllib.request
+import io
+import json
+import urllib.parse
+import urllib.request
+from math import pi

+import comfy.model_management as model_management
+import comfy.utils
 import numpy as np
 import torch
 from PIL import Image

 from ..log import log
-from ..utils import apply_easing, get_server_info, pil2tensor
+from ..utils import (
+    EASINGS,
+    apply_easing,
+    get_server_info,
+    numpy_NFOV,
+    pil2tensor,
+    tensor2np,
+)


 def get_image(filename, subfolder, folder_type):
@@ -32,6 +44,7 @@ class MTB_ToDevice:
        if torch.backends.mps.is_available():
            devices.append("mps")
        if torch.cuda.is_available():
+            devices.append("cuda")
            for i in range(torch.cuda.device_count()):
                devices.append(f"cuda{i}")

@@ -56,8 +69,8 @@ class MTB_ToDevice:
        *,
        ignore_errors=False,
        device="cuda",
-        image: Optional[torch.Tensor] = None,
-        mask: Optional[torch.Tensor] = None,
+        image: torch.Tensor | None = None,
+        mask: torch.Tensor | None = None,
    ):
        if not ignore_errors and image is None and mask is None:
            raise ValueError(
@@ -73,6 +86,14 @@ class MTB_ToDevice:

 # class MTB_ApplyTextTemplate:
 class MTB_ApplyTextTemplate:
+    """
+    Experimental node to interpolate strings from inputs.
+
+    Interpolation just requires {}, for instance:
+
+    Some string {var_1} and {var_2}
+    """
+
    @classmethod
    def INPUT_TYPES(cls):
        return {
@@ -94,7 +115,214 @@ class MTB_ApplyTextTemplate:
        return (res,)


-class GetBatchFromHistory:
+class MTB_MatchDimensions:
+    """Match images dimensions along the given dimension, preserving aspect ratio."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "source": ("IMAGE",),
+                "reference": ("IMAGE",),
+                "match": (["height", "width"], {"default": "height"}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT", "INT")
+    RETURN_NAMES = ("image", "new_width", "new_height")
+    CATEGORY = "mtb/utils"
+    FUNCTION = "execute"
+
+    def execute(
+        self, source: torch.Tensor, reference: torch.Tensor, match: str
+    ):
+        import torchvision.transforms.functional as VF
+
+        _batch_size, height, width, _channels = source.shape
+        _rbatch_size, rheight, rwidth, _rchannels = reference.shape
+
+        source_aspect_ratio = width / height
+        # reference_aspect_ratio = rwidth / rheight
+
+        source = source.permute(0, 3, 1, 2)
+        reference = reference.permute(0, 3, 1, 2)
+
+        if match == "height":
+            new_height = rheight
+            new_width = int(rheight * source_aspect_ratio)
+        else:
+            new_width = rwidth
+            new_height = int(rwidth / source_aspect_ratio)
+
+        resized_images = [
+            VF.resize(
+                source[i],
+                (new_height, new_width),
+                antialias=True,
+                interpolation=Image.BICUBIC,
+            )
+            for i in range(_batch_size)
+        ]
+        resized_source = torch.stack(resized_images, dim=0)
+        resized_source = resized_source.permute(0, 2, 3, 1)
+
+        return (resized_source, new_width, new_height)
+
+
+class MTB_FloatToFloats:
+    """Conversion utility for compatibility with other extensions (AD, IPA, Fitz are using FLOAT to represent list of floats.)"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "float": ("FLOAT", {"default": 0.0, "forceInput": True}),
+            }
+        }
+
+    RETURN_TYPES = ("FLOATS",)
+    RETURN_NAMES = ("floats",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "convert"
+
+    def convert(self, float: float):
+        return (float,)
+
+
+class MTB_FloatsToInts:
+    """Conversion utility for compatibility with frame interpolation."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "floats": ("FLOATS", {"forceInput": True}),
+            }
+        }
+
+    RETURN_TYPES = ("INTS", "INT")
+    CATEGORY = "mtb/utils"
+    FUNCTION = "convert"
+
+    def convert(self, floats: list[float]):
+        vals = [int(x) for x in floats]
+        return (vals, vals)
+
+
+class MTB_FloatsToFloat:
+    """Conversion utility for compatibility with other extensions (AD, IPA, Fitz are using FLOAT to represent list of floats.)"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "floats": ("FLOATS",),
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    RETURN_NAMES = ("float",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "convert"
+
+    def convert(self, floats):
+        return (floats,)
+
+
+class MTB_AutoPanEquilateral:
+    """Generate a 360 panning video from an equilateral image."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "equilateral_image": ("IMAGE",),
+                "fovX": ("FLOAT", {"default": 45.0}),
+                "fovY": ("FLOAT", {"default": 45.0}),
+                "elevation": ("FLOAT", {"default": 0.5}),
+                "frame_count": ("INT", {"default": 100}),
+                "width": ("INT", {"default": 768}),
+                "height": ("INT", {"default": 512}),
+            },
+            "optional": {
+                "floats_fovX": ("FLOATS",),
+                "floats_fovY": ("FLOATS",),
+                "floats_elevation": ("FLOATS",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "generate_frames"
+
+    def check_floats(self, f: list[float] | None, expected_count: int):
+        if f:
+            if len(f) == expected_count:
+                return True
+            return False
+        return True
+
+    def generate_frames(
+        self,
+        equilateral_image: torch.Tensor,
+        fovX: float,
+        fovY: float,
+        elevation: float,
+        frame_count: int,
+        width: int,
+        height: int,
+        floats_fovX: list[float] | None = None,
+        floats_fovY: list[float] | None = None,
+        floats_elevation: list[float] | None = None,
+    ):
+        source = tensor2np(equilateral_image)
+
+        if len(source) > 1:
+            log.warn(
+                "You provided more than one image in the equilateral_image input, only the first will be used."
+            )
+        if not all(
+            [
+                self.check_floats(x, frame_count)
+                for x in [floats_fovX, floats_fovY, floats_elevation]
+            ]
+        ):
+            raise ValueError(
+                "You provided less than the expected number of fovX, fovY, or elevation values."
+            )
+
+        source = source[0]
+        frames = []
+
+        pbar = comfy.utils.ProgressBar(frame_count)
+        for i in range(frame_count):
+            rotation_angle = (i / frame_count) * 2 * pi
+
+            if floats_elevation:
+                elevation = floats_elevation[i]
+
+            if floats_fovX:
+                fovX = floats_fovX[i]
+
+            if floats_fovY:
+                fovY = floats_fovY[i]
+
+            fov = [fovX / 100, fovY / 100]
+            center_point = [rotation_angle / (2 * pi), elevation]
+
+            nfov = numpy_NFOV(fov, height, width)
+            frame = nfov.to_nfov(source, center_point=center_point)
+
+            frames.append(frame)
+
+            model_management.throw_exception_if_processing_interrupted()
+            pbar.update(1)
+
+        return (pil2tensor(frames),)
+
+
+class MTB_GetBatchFromHistory:
    """Very experimental node to load images from the history of the server.

    Queue items without output are ignored in the count.
@@ -183,13 +411,13 @@ class GetBatchFromHistory:
        return pil2tensor(frames)


-class AnyToString:
+class MTB_AnyToString:
    """Tries to take any input and convert it to a string."""

    @classmethod
    def INPUT_TYPES(cls):
        return {
-            "required": {"input": ("*")},
+            "required": {"input": ("*",)},
        }

    RETURN_TYPES = ("STRING",)
@@ -218,7 +446,7 @@ class AnyToString:
            return (str(input),)


-class StringReplace:
+class MTB_StringReplace:
    """Basic string replacement."""

    @classmethod
@@ -263,15 +491,14 @@ class MTB_MathExpression:
    RETURN_NAMES = ("result (float)", "result (int)")
    CATEGORY = "mtb/math"
    DESCRIPTION = (
-        "evaluate a simple math expression string (!! Fallsback to eval)"
+        "evaluate a simple math expression string, only supports literal_eval"
    )

-    def eval_expression(self, expression, **kwargs):
-        import math
+    def eval_expression(self, expression: str, **kwargs):
        from ast import literal_eval

        for key, value in kwargs.items():
-            print(f"Replacing placeholder <{key}> with value {value}")
+            log.debug(f"Replacing placeholder <{key}> with value {value}")
            expression = expression.replace(f"<{key}>", str(value))

        result = -1
@@ -282,20 +509,15 @@ class MTB_MathExpression:
                f"The expression syntax is wrong '{expression}': {e}"
            ) from e

-        except ValueError:
-            try:
-                expression = expression.replace("^", "**")
-                result = eval(expression)
-            except Exception as e:
-                # Handle any other exceptions and provide a meaningful error message
-                raise ValueError(
-                    f"Error evaluating expression '{expression}': {e}"
-                ) from e
+        except Exception as e:
+            raise ValueError(
+                f"Math expression only support literal_eval now: {e}"
+            )

        return (result, int(result))


-class FitNumber:
+class MTB_FitNumber:
    """Fit the input float using a source and target range"""

    @classmethod
@@ -304,35 +526,24 @@ class FitNumber:
            "required": {
                "value": ("FLOAT", {"default": 0, "forceInput": True}),
                "clamp": ("BOOLEAN", {"default": False}),
-                "source_min": ("FLOAT", {"default": 0.0, "step": 0.01}),
-                "source_max": ("FLOAT", {"default": 1.0, "step": 0.01}),
-                "target_min": ("FLOAT", {"default": 0.0, "step": 0.01}),
-                "target_max": ("FLOAT", {"default": 1.0, "step": 0.01}),
+                "source_min": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 0.01, "min": -1e5},
+                ),
+                "source_max": (
+                    "FLOAT",
+                    {"default": 1.0, "step": 0.01, "min": -1e5},
+                ),
+                "target_min": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 0.01, "min": -1e5},
+                ),
+                "target_max": (
+                    "FLOAT",
+                    {"default": 1.0, "step": 0.01, "min": -1e5},
+                ),
                "easing": (
-                    [
-                        "Linear",
-                        "Sine In",
-                        "Sine Out",
-                        "Sine In/Out",
-                        "Quart In",
-                        "Quart Out",
-                        "Quart In/Out",
-                        "Cubic In",
-                        "Cubic Out",
-                        "Cubic In/Out",
-                        "Circ In",
-                        "Circ Out",
-                        "Circ In/Out",
-                        "Back In",
-                        "Back Out",
-                        "Back In/Out",
-                        "Elastic In",
-                        "Elastic Out",
-                        "Elastic In/Out",
-                        "Bounce In",
-                        "Bounce Out",
-                        "Bounce In/Out",
-                    ],
+                    EASINGS,
                    {"default": "Linear"},
                ),
            }
@@ -368,7 +579,7 @@ class FitNumber:
        return (res,)


-class ConcatImages:
+class MTB_ConcatImages:
    """Add images to batch."""

    RETURN_TYPES = ("IMAGE",)
@@ -379,29 +590,81 @@ class ConcatImages:
    def INPUT_TYPES(cls):
        return {
            "required": {"reverse": ("BOOLEAN", {"default": False})},
+            "optional": {
+                "on_mismatch": (
+                    ["Error", "Smallest", "Largest"],
+                    {"default": "Smallest"},
+                )
+            },
        }

-    def concatenate_tensors(self, reverse, **kwargs):
-        tensors = tuple(kwargs.values())
-        batch_sizes = [tensor.size(0) for tensor in tensors]
+    def concatenate_tensors(
+        self,
+        reverse: bool,
+        on_mismatch: str = "Smallest",
+        **kwargs: torch.Tensor,
+    ) -> tuple[torch.Tensor]:
+        tensors = list(kwargs.values())
+
+        if on_mismatch == "Error":
+            shapes = [tensor.shape for tensor in tensors]
+            if not all(shape == shapes[0] for shape in shapes):
+                raise ValueError(
+                    "All input tensors must have the same shape when on_mismatch is 'Error'."
+                )
+
+        else:
+            import torch.nn.functional as F
+
+            if on_mismatch == "Smallest":
+                target_shape = min(
+                    (tensor.shape for tensor in tensors),
+                    key=lambda s: (s[1], s[2]),
+                )
+            else:  # on_mismatch == "Largest"
+                target_shape = max(
+                    (tensor.shape for tensor in tensors),
+                    key=lambda s: (s[1], s[2]),
+                )
+
+            target_height, target_width = target_shape[1], target_shape[2]
+
+            resized_tensors = []
+            for tensor in tensors:
+                if (
+                    tensor.shape[1] != target_height
+                    or tensor.shape[2] != target_width
+                ):
+                    resized_tensor = F.interpolate(
+                        tensor.permute(0, 3, 1, 2),
+                        size=(target_height, target_width),
+                        mode="bilinear",
+                        align_corners=False,
+                    )
+                    resized_tensor = resized_tensor.permute(0, 2, 3, 1)
+                    resized_tensors.append(resized_tensor)
+                else:
+                    resized_tensors.append(tensor)
+
+            tensors = resized_tensors

        concatenated = torch.cat(tensors, dim=0)

-        # Update the batch size in the concatenated tensor
-        concatenated_size = list(concatenated.size())
-        concatenated_size[0] = sum(batch_sizes)
-        concatenated = concatenated.view(*concatenated_size)
-
        return (concatenated,)


 __nodes__ = [
-    StringReplace,
-    FitNumber,
-    GetBatchFromHistory,
-    AnyToString,
-    ConcatImages,
+    MTB_StringReplace,
+    MTB_FitNumber,
+    MTB_GetBatchFromHistory,
+    MTB_AnyToString,
+    MTB_ConcatImages,
    MTB_MathExpression,
    MTB_ToDevice,
    MTB_ApplyTextTemplate,
+    MTB_MatchDimensions,
+    MTB_AutoPanEquilateral,
+    MTB_FloatsToFloat,
+    MTB_FloatToFloats,
+    MTB_FloatsToInts,
 ]
@@ -1,12 +1,9 @@
-import glob
-import os
 from pathlib import Path
 from typing import List

 import comfy
 import comfy.model_management as model_management
 import comfy.utils
-import folder_paths
 import numpy as np
 import tensorflow as tf
 import torch
@@ -17,7 +14,7 @@ from ..log import log
 from ..utils import get_model_path


-class LoadFilmModel:
+class MTB_LoadFilmModel:
    """Loads a FILM model"""

    @staticmethod
@@ -58,7 +55,7 @@ class LoadFilmModel:
        return (interpolator.Interpolator(model_path.as_posix(), None),)


-class FilmInterpolation:
+class MTB_FilmInterpolation:
    """Google Research FILM frame interpolation for large motion"""

    @classmethod
@@ -107,12 +104,16 @@ class FilmInterpolation:
            in_frames, interpolate, film_model
        ):
            out_tensors.append(
-                torch.from_numpy(frame) if isinstance(frame, np.ndarray) else frame
+                torch.from_numpy(frame)
+                if isinstance(frame, np.ndarray)
+                else frame
            )
            model_management.throw_exception_if_processing_interrupted()
            pbar.update(1)

-        out_tensors = torch.cat([tens.unsqueeze(0) for tens in out_tensors], dim=0)
+        out_tensors = torch.cat(
+            [tens.unsqueeze(0) for tens in out_tensors], dim=0
+        )

        log.debug(f"Returning {len(out_tensors)} tensors")
        log.debug(f"Output shape {out_tensors.shape}")
@@ -120,4 +121,4 @@ class FilmInterpolation:
        return (out_tensors,)


-__nodes__ = [LoadFilmModel, FilmInterpolation]
+__nodes__ = [MTB_LoadFilmModel, MTB_FilmInterpolation]
@@ -3,6 +3,7 @@ import json
 import math
 import os

+import comfy.model_management as model_management
 import folder_paths
 import numpy as np
 import torch
@@ -13,7 +14,7 @@ from skimage.filters import gaussian
 from skimage.util import compare_images

 from ..log import log
-from ..utils import pil2tensor, tensor2np, tensor2pil
+from ..utils import np2tensor, pil2tensor, tensor2pil

 # try:
 #     from cv2.ximgproc import guidedFilter
@@ -35,7 +36,344 @@ def gaussian_kernel(
    return g / g.sum()


-class ColorCorrect:
+class MTB_CoordinatesToString:
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "convert"
+    CATEGORY = "mtb/coordinates"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "coordinates": ("BATCH_COORDINATES",),
+                "frame": ("INT",),
+            }
+        }
+
+    def convert(
+        self, coordinates: list[list[tuple[int, int]]], frame: int
+    ) -> tuple[str]:
+        frame = max(frame, len(coordinates) - 1)
+        coords = coordinates[frame]
+        output: list[dict[str, int]] = []
+
+        for x, y in coords:
+            output.append({"x": x, "y": y})
+
+        return (json.dumps(output),)
+
+
+class MTB_ExtractCoordinatesFromImage:
+    """Extract 2D points from a batch of images based on a threshold."""
+
+    RETURN_TYPES = ("BATCH_COORDINATES", "IMAGE")
+    FUNCTION = "extract"
+    CATEGORY = "mtb/coordinates"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "threshold": ("FLOAT",),
+                "max_points": ("INT", {"default": 50, "min": 0}),
+            },
+            "optional": {"image": ("IMAGE",), "mask": ("MASK",)},
+        }
+
+    def extract(
+        self,
+        threshold: float,
+        max_points: int,
+        image: torch.Tensor | None = None,
+        mask: torch.Tensor | None = None,
+    ) -> tuple[list[list[tuple[int, int]]], torch.Tensor]:
+        if image is not None:
+            batch_count, height, width, channel_count = image.shape
+            imgs = image
+        else:
+            if mask is None:
+                raise ValueError("Must provide either image or mask")
+            batch_count, height, width = mask.shape
+            channel_count = 1
+            imgs = mask
+
+        if channel_count not in [1, 2, 3, 4]:
+            raise ValueError(f"Incorrect channel count: {channel_count}")
+
+        all_points: list[list[tuple[int, int]]] = []
+        debug_images = torch.zeros(
+            (batch_count, height, width, 3),
+            dtype=torch.uint8,
+            device=imgs.device,
+        )
+
+        for i, img in enumerate(imgs):
+            if channel_count == 1:
+                alpha_channel = img if len(img.shape) == 2 else img[:, :, 0]
+            elif channel_count == 2:
+                alpha_channel = img[:, :, 1]
+            elif channel_count == 4:
+                alpha_channel = img[:, :, 3]
+            else:
+                # get intensity
+                alpha_channel = img[:, :, :3].max(dim=2)[0]
+
+            points = (alpha_channel > threshold).nonzero(as_tuple=False)
+
+            if len(points) > max_points:
+                indices = torch.randperm(points.size(0), device=img.device)[
+                    :max_points
+                ]
+                points = points[indices]
+
+            points = [(int(y.item()), int(x.item())) for x, y in points]
+            all_points.append(points)
+
+            for x, y in points:
+                self._draw_circle(debug_images[i], (x, y), 5)
+
+        return (all_points, debug_images)
+
+    @staticmethod
+    def _draw_circle(
+        image: torch.Tensor, center: tuple[int, int], radius: int
+    ):
+        """Draw a 5px circle on the image."""
+        x0, y0 = center
+        for x in range(-radius, radius + 1):
+            for y in range(-radius, radius + 1):
+                in_radius = x**2 + y**2 <= radius**2
+                in_bounds = (
+                    0 <= x0 + x < image.shape[1]
+                    and 0 <= y0 + y < image.shape[0]
+                )
+                if in_radius and in_bounds:
+                    image[y0 + y, x0 + x] = torch.tensor(
+                        [255, 255, 255],
+                        dtype=torch.uint8,
+                        device=image.device,
+                    )
+
+
+class MTB_ColorCorrectGPU:
+    """Various color correction methods using only Torch."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "force_gpu": ("BOOLEAN", {"default": True}),
+                "clamp": ([True, False], {"default": True}),
+                "gamma": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01},
+                ),
+                "contrast": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01},
+                ),
+                "exposure": (
+                    "FLOAT",
+                    {"default": 0.0, "min": -5.0, "max": 5.0, "step": 0.01},
+                ),
+                "offset": (
+                    "FLOAT",
+                    {"default": 0.0, "min": -5.0, "max": 5.0, "step": 0.01},
+                ),
+                "hue": (
+                    "FLOAT",
+                    {"default": 0.0, "min": -0.5, "max": 0.5, "step": 0.01},
+                ),
+                "saturation": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01},
+                ),
+                "value": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01},
+                ),
+            },
+            "optional": {"mask": ("MASK",)},
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "correct"
+    CATEGORY = "mtb/image processing"
+
+    @staticmethod
+    def get_device(tensor: torch.Tensor, force_gpu: bool):
+        if force_gpu:
+            if torch.cuda.is_available():
+                return torch.device("cuda")
+            elif (
+                hasattr(torch.backends, "mps")
+                and torch.backends.mps.is_available()
+            ):
+                return torch.device("mps")
+            elif hasattr(torch, "hip") and torch.hip.is_available():
+                return torch.device("hip")
+        return (
+            tensor.device
+        )  # model_management.get_torch_device() # torch.device("cpu")
+
+    @staticmethod
+    def rgb_to_hsv(image: torch.Tensor):
+        r, g, b = image.unbind(-1)
+        max_rgb, argmax_rgb = image.max(-1)
+        min_rgb, _ = image.min(-1)
+
+        diff = max_rgb - min_rgb
+
+        h = torch.empty_like(max_rgb)
+        s = diff / (max_rgb + 1e-7)
+        v = max_rgb
+
+        h[argmax_rgb == 0] = (g - b)[argmax_rgb == 0] / (diff + 1e-7)[
+            argmax_rgb == 0
+        ]
+        h[argmax_rgb == 1] = (
+            2.0 + (b - r)[argmax_rgb == 1] / (diff + 1e-7)[argmax_rgb == 1]
+        )
+        h[argmax_rgb == 2] = (
+            4.0 + (r - g)[argmax_rgb == 2] / (diff + 1e-7)[argmax_rgb == 2]
+        )
+        h = (h / 6.0) % 1.0
+
+        h = h.unsqueeze(-1)
+        s = s.unsqueeze(-1)
+        v = v.unsqueeze(-1)
+
+        return torch.cat((h, s, v), dim=-1)
+
+    @staticmethod
+    def hsv_to_rgb(hsv: torch.Tensor):
+        h, s, v = hsv.unbind(-1)
+        h = h * 6.0
+
+        i = torch.floor(h)
+        f = h - i
+        p = v * (1.0 - s)
+        q = v * (1.0 - s * f)
+        t = v * (1.0 - s * (1.0 - f))
+
+        i = i.long() % 6
+
+        mask = torch.stack(
+            (i == 0, i == 1, i == 2, i == 3, i == 4, i == 5), -1
+        )
+
+        rgb = torch.stack(
+            (
+                torch.where(
+                    mask[..., 0],
+                    v,
+                    torch.where(
+                        mask[..., 1],
+                        q,
+                        torch.where(
+                            mask[..., 2],
+                            p,
+                            torch.where(
+                                mask[..., 3],
+                                p,
+                                torch.where(mask[..., 4], t, v),
+                            ),
+                        ),
+                    ),
+                ),
+                torch.where(
+                    mask[..., 0],
+                    t,
+                    torch.where(
+                        mask[..., 1],
+                        v,
+                        torch.where(
+                            mask[..., 2],
+                            v,
+                            torch.where(
+                                mask[..., 3],
+                                q,
+                                torch.where(mask[..., 4], p, p),
+                            ),
+                        ),
+                    ),
+                ),
+                torch.where(
+                    mask[..., 0],
+                    p,
+                    torch.where(
+                        mask[..., 1],
+                        p,
+                        torch.where(
+                            mask[..., 2],
+                            t,
+                            torch.where(
+                                mask[..., 3],
+                                v,
+                                torch.where(mask[..., 4], v, q),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+            dim=-1,
+        )
+
+        return rgb
+
+    def correct(
+        self,
+        image: torch.Tensor,
+        force_gpu: bool,
+        clamp: bool,
+        gamma: float = 1.0,
+        contrast: float = 1.0,
+        exposure: float = 0.0,
+        offset: float = 0.0,
+        hue: float = 0.0,
+        saturation: float = 1.0,
+        value: float = 1.0,
+        mask: torch.Tensor | None = None,
+    ):
+        device = self.get_device(image, force_gpu)
+        image = image.to(device)
+
+        if mask is not None:
+            if mask.shape[0] != image.shape[0]:
+                mask = mask.expand(image.shape[0], -1, -1)
+
+            mask = mask.unsqueeze(-1).expand(-1, -1, -1, 3)
+            mask = mask.to(device)
+
+        model_management.throw_exception_if_processing_interrupted()
+        adjusted = image.pow(1 / gamma) * (2.0**exposure) * contrast + offset
+
+        model_management.throw_exception_if_processing_interrupted()
+        hsv = self.rgb_to_hsv(adjusted)
+        hsv[..., 0] = (hsv[..., 0] + hue) % 1.0  # Hue
+        hsv[..., 1] = hsv[..., 1] * saturation  # Saturation
+        hsv[..., 2] = hsv[..., 2] * value  # Value
+        adjusted = self.hsv_to_rgb(hsv)
+
+        model_management.throw_exception_if_processing_interrupted()
+        if clamp:
+            adjusted = torch.clamp(adjusted, 0.0, 1.0)
+
+        # apply mask
+        result = (
+            adjusted
+            if mask is None
+            else torch.where(mask > 0, adjusted, image)
+        )
+
+        if not force_gpu:
+            result = result.cpu()
+
+        return (result,)
+
+
+class MTB_ColorCorrect:
    """Various color correction methods"""

    @classmethod
@@ -72,7 +410,8 @@ class ColorCorrect:
                    "FLOAT",
                    {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01},
                ),
-            }
+            },
+            "optional": {"mask": ("MASK",)},
        }

    RETURN_TYPES = ("IMAGE",)
@@ -86,7 +425,14 @@ class ColorCorrect:

    @staticmethod
    def contrast_adjustment_tensor(image, contrast):
-        contrasted = (image - 0.5) * contrast + 0.5
+        r, g, b = image.unbind(-1)
+
+        # Using Adobe RGB luminance weights.
+        luminance_image = 0.33 * r + 0.71 * g + 0.06 * b
+        luminance_mean = torch.mean(luminance_image.unsqueeze(-1))
+
+        # Blend original with mean luminance using contrast factor as blend ratio.
+        contrasted = image * contrast + (1.0 - contrast) * luminance_mean
        return torch.clamp(contrasted, 0.0, 1.0)

    @staticmethod
@@ -181,21 +527,34 @@ class ColorCorrect:
        hue: float = 0.0,
        saturation: float = 1.0,
        value: float = 1.0,
+        mask: torch.Tensor | None = None,
    ):
+        if mask is not None:
+            if mask.shape[0] != image.shape[0]:
+                mask = mask.expand(image.shape[0], -1, -1)
+
+            mask = mask.unsqueeze(-1).expand(-1, -1, -1, 3)
+
        # Apply color correction operations
-        image = self.gamma_correction_tensor(image, gamma)
-        image = self.contrast_adjustment_tensor(image, contrast)
-        image = self.exposure_adjustment_tensor(image, exposure)
-        image = self.offset_adjustment_tensor(image, offset)
-        image = self.hsv_adjustment(image, hue, saturation, value)
+        adjusted = self.gamma_correction_tensor(image, gamma)
+        adjusted = self.contrast_adjustment_tensor(adjusted, contrast)
+        adjusted = self.exposure_adjustment_tensor(adjusted, exposure)
+        adjusted = self.offset_adjustment_tensor(adjusted, offset)
+        adjusted = self.hsv_adjustment(adjusted, hue, saturation, value)

        if clamp:
-            image = torch.clamp(image, 0.0, 1.0)
+            adjusted = torch.clamp(image, 0.0, 1.0)

-        return (image,)
+        result = (
+            adjusted
+            if mask is None
+            else torch.where(mask > 0, adjusted, image)
+        )
+
+        return (result,)


-class ImageCompare_:
+class MTB_ImageCompare:
    """Compare two images and return a difference image"""

    @classmethod
@@ -216,22 +575,61 @@ class ImageCompare_:
    CATEGORY = "mtb/image"

    def compare(self, imageA: torch.Tensor, imageB: torch.Tensor, mode):
-        imageA = imageA.numpy()
-        imageB = imageB.numpy()
+        if imageA.dim() == 4:
+            batch_count = imageA.size(0)
+            return (
+                torch.cat(
+                    tuple(
+                        self.compare(imageA[i], imageB[i], mode)[0]
+                        for i in range(batch_count)
+                    ),
+                    dim=0,
+                ),
+            )

-        imageA = imageA.squeeze()
-        imageB = imageB.squeeze()
+        num_channels_A = imageA.size(2)
+        num_channels_B = imageB.size(2)

-        image = compare_images(imageA, imageB, method=mode)
+        # handle RGBA/RGB mismatch
+        if num_channels_A == 3 and num_channels_B == 4:
+            imageA = torch.cat(
+                (imageA, torch.ones_like(imageA[:, :, 0:1])), dim=2
+            )
+        elif num_channels_B == 3 and num_channels_A == 4:
+            imageB = torch.cat(
+                (imageB, torch.ones_like(imageB[:, :, 0:1])), dim=2
+            )
+        match mode:
+            case "diff":
+                compare_image = torch.abs(imageA - imageB)
+            case "blend":
+                compare_image = 0.5 * (imageA + imageB)
+            case "checkerboard":
+                imageA = imageA.numpy()
+                imageB = imageB.numpy()
+                compared_channels = [
+                    torch.from_numpy(
+                        compare_images(
+                            imageA[:, :, i], imageB[:, :, i], method=mode
+                        )
+                    )
+                    for i in range(imageA.shape[2])
+                ]

-        image = np.expand_dims(image, axis=0)
-        return (torch.from_numpy(image),)
+                compare_image = torch.stack(compared_channels, dim=2)
+            case _:
+                compare_image = None
+                raise ValueError(f"Unknown mode {mode}")
+
+        compare_image = compare_image.unsqueeze(0)
+
+        return (compare_image,)


 import requests


-class LoadImageFromUrl_:
+class MTB_LoadImageFromUrl:
    """Load an image from the given URL"""

    @classmethod
@@ -258,7 +656,7 @@ class LoadImageFromUrl_:
        return (pil2tensor(image),)


-class Blur_:
+class MTB_Blur:
    """Blur an image using a Gaussian filter."""

    @classmethod
@@ -268,28 +666,55 @@ class Blur_:
                "image": ("IMAGE",),
                "sigmaX": (
                    "FLOAT",
-                    {"default": 3.0, "min": 0.0, "max": 10.0, "step": 0.01},
+                    {"default": 3.0, "min": 0.0, "max": 200.0, "step": 0.01},
                ),
                "sigmaY": (
                    "FLOAT",
-                    {"default": 3.0, "min": 0.0, "max": 10.0, "step": 0.01},
+                    {"default": 3.0, "min": 0.0, "max": 200.0, "step": 0.01},
                ),
-            }
+            },
+            "optional": {"sigmasX": ("FLOATS",), "sigmasY": ("FLOATS",)},
        }

    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "blur"
    CATEGORY = "mtb/image processing"

-    def blur(self, image: torch.Tensor, sigmaX, sigmaY):
-        image = image.numpy()
-        image = image.transpose(1, 2, 3, 0)
-        image = gaussian(image, sigma=(sigmaX, sigmaY, 0, 0))
-        image = image.transpose(3, 0, 1, 2)
-        return (torch.from_numpy(image),)
+    def blur(
+        self, image: torch.Tensor, sigmaX, sigmaY, sigmasX=None, sigmasY=None
+    ):
+        image_np = image.numpy() * 255
+
+        blurred_images = []
+        if sigmasX is not None:
+            if sigmasY is None:
+                sigmasY = sigmasX
+            if len(sigmasX) != image.size(0):
+                raise ValueError(
+                    f"SigmasX must have same length as image, sigmasX is {len(sigmasX)} but the batch size is {image.size(0)}"
+                )
+
+            for i in range(image.size(0)):
+                blurred = gaussian(
+                    image_np[i],
+                    sigma=(sigmasX[i], sigmasY[i], 0),
+                    channel_axis=2,
+                )
+                blurred_images.append(blurred)
+
+            image_np = np.array(blurred_images)
+        else:
+            for i in range(image.size(0)):
+                blurred = gaussian(
+                    image_np[i], sigma=(sigmaX, sigmaY, 0), channel_axis=2
+                )
+                blurred_images.append(blurred)
+
+            image_np = np.array(blurred_images)
+        return (np2tensor(image_np).squeeze(0),)


-class Sharpen_:
+class MTB_Sharpen:
    """Sharpens an image using a Gaussian kernel."""

    @classmethod
@@ -392,7 +817,7 @@ class Sharpen_:
 #         return (np2tensor(deglaze_np_img(tensor2np(image))),)


-class MaskToImage:
+class MTB_MaskToImage:
    """Converts a mask (alpha) to an RGB image with a color and background"""

    @classmethod
@@ -402,7 +827,10 @@ class MaskToImage:
                "mask": ("MASK",),
                "color": ("COLOR",),
                "background": ("COLOR", {"default": "#000000"}),
-            }
+            },
+            "optional": {
+                "invert": ("BOOLEAN", {"default": False}),
+            },
        }

    CATEGORY = "mtb/generate"
@@ -411,11 +839,12 @@ class MaskToImage:

    FUNCTION = "render_mask"

-    def render_mask(self, mask, color, background):
-        masks = tensor2np(mask)
+    def render_mask(self, mask, color, background, invert=False):
+        masks = tensor2pil(1.0 - mask) if invert else tensor2pil(mask)
        images = []
+
        for m in masks:
-            _mask = Image.fromarray(m).convert("L")
+            _mask = m.convert("L")

            log.debug(
                f"Converted mask to PIL Image format, size: {_mask.size}"
@@ -436,10 +865,7 @@ class MaskToImage:
        return (pil2tensor(images),)


-from typing import Optional
-
-
-class ColoredImage:
+class MTB_ColoredImage:
    """Constant color image of given size."""

    def __init__(self) -> None:
@@ -456,6 +882,11 @@ class ColoredImage:
            "optional": {
                "foreground_image": ("IMAGE",),
                "foreground_mask": ("MASK",),
+                "invert": ("BOOLEAN", {"default": False}),
+                "mask_opacity": (
+                    "FLOAT",
+                    {"default": 1.0, "step": 0.1, "min": 0},
+                ),
            },
        }

@@ -465,28 +896,19 @@ class ColoredImage:

    FUNCTION = "render_img"

-    def resize_and_crop(self, img, target_size):
-        # Calculate scaling factors for both dimensions
-        scale_x = target_size[0] / img.width
-        scale_y = target_size[1] / img.height
-
-        # Use the smaller scaling factor to maintain aspect ratio
-        scale = max(scale_x, scale_y)
-
-        # Resize the image based on calculated scale
+    def resize_and_crop(self, img: Image.Image, target_size: tuple[int, int]):
+        scale = max(target_size[0] / img.width, target_size[1] / img.height)
        new_size = (int(img.width * scale), int(img.height * scale))
        img = img.resize(new_size, Image.LANCZOS)
+        left = (img.width - target_size[0]) // 2
+        top = (img.height - target_size[1]) // 2
+        return img.crop(
+            (left, top, left + target_size[0], top + target_size[1])
+        )

-        # Calculate cropping coordinates
-        left = (img.width - target_size[0]) / 2
-        top = (img.height - target_size[1]) / 2
-        right = (img.width + target_size[0]) / 2
-        bottom = (img.height + target_size[1]) / 2
-
-        # Crop and return the image
-        return img.crop((left, top, right, bottom))
-
-    def resize_and_crop_thumbnails(self, img, target_size):
+    def resize_and_crop_thumbnails(
+        self, img: Image.Image, target_size: tuple[int, int]
+    ):
        img.thumbnail(target_size, Image.LANCZOS)
        left = (img.width - target_size[0]) / 2
        top = (img.height - target_size[1]) / 2
@@ -494,65 +916,74 @@ class ColoredImage:
        bottom = (img.height + target_size[1]) / 2
        return img.crop((left, top, right, bottom))

+    @staticmethod
+    def process_mask(
+        mask: torch.Tensor | None,
+        invert: bool,
+        # opacity: float,
+        batch_size: int,
+    ) -> list[Image.Image] | None:
+        if mask is None:
+            return [None] * batch_size
+
+        masks = tensor2pil(mask if not invert else 1.0 - mask)
+
+        if len(masks) == 1 and batch_size > 1:
+            masks = masks * batch_size
+
+        if len(masks) != batch_size:
+            raise ValueError(
+                "Foreground image and mask must have the same batch size"
+            )
+
+        return masks
+
    def render_img(
        self,
-        color,
-        width,
-        height,
-        foreground_image: Optional[torch.Tensor] = None,
-        foreground_mask: Optional[torch.Tensor] = None,
-    ):
-        image = Image.new("RGBA", (width, height), color=color)
-        output = []
-        if foreground_image is not None:
-            fg_images = tensor2pil(foreground_image)
-            fg_masks = [None] * len(
-                fg_images
-            )  # Default to None for each foreground image
+        color: str,
+        width: int,
+        height: int,
+        foreground_image: torch.Tensor | None = None,
+        foreground_mask: torch.Tensor | None = None,
+        invert: bool = False,
+        mask_opacity: float = 1.0,
+    ) -> tuple[torch.Tensor]:
+        background = Image.new("RGBA", (width, height), color=color)

-            if foreground_mask is not None:
-                if foreground_image.size()[0] != foreground_mask.size()[0]:
+        if foreground_image is None:
+            return (pil2tensor([background.convert("RGB")]),)
+
+        fg_images = tensor2pil(foreground_image)
+        fg_masks = self.process_mask(foreground_mask, invert, len(fg_images))
+
+        output: list[Image.Image] = []
+        for fg_image, fg_mask in zip(fg_images, fg_masks, strict=False):
+            fg_image = self.resize_and_crop(fg_image, background.size)
+
+            if fg_mask:
+                fg_mask = self.resize_and_crop(fg_mask, background.size)
+
+                fg_mask_array = np.array(fg_mask)
+                fg_mask_array = (fg_mask_array * mask_opacity).astype(np.uint8)
+                fg_mask = Image.fromarray(fg_mask_array)
+                output.append(
+                    Image.composite(
+                        fg_image.convert("RGBA"), background, fg_mask
+                    ).convert("RGB")
+                )
+            else:
+                if fg_image.mode != "RGBA":
                    raise ValueError(
-                        "Foreground image and mask must have same batch size"
+                        f"Foreground image must be in 'RGBA' mode when no mask is provided, got {fg_image.mode}"
                    )
-                fg_masks = tensor2pil(foreground_mask.unsqueeze(-1))
+                output.append(
+                    Image.alpha_composite(background, fg_image).convert("RGB")
+                )

-            for fg_image, fg_mask in zip(fg_images, fg_masks):
-                # Resize and crop if dimensions mismatch
-                if fg_image.size != image.size:
-                    fg_image = self.resize_and_crop(fg_image, image.size)
-                    if fg_mask:
-                        fg_mask = self.resize_and_crop(fg_mask, image.size)
-
-                if fg_mask:
-                    output.append(
-                        Image.composite(
-                            fg_image.convert("RGBA"),
-                            image,
-                            fg_mask,
-                        ).convert("RGB")
-                    )
-                else:
-                    if fg_image.mode != "RGBA":
-                        raise ValueError(
-                            "Foreground image must be in 'RGBA' mode "
-                            f"when no mask is provided, got {fg_image.mode}"
-                        )
-                    output.append(
-                        Image.alpha_composite(image, fg_image).convert("RGB")
-                    )
-
-        else:
-            if foreground_mask is not None:
-                log.warn("Mask ignored because no foreground image is given")
-            output.append(image.convert("RGB"))
-
-        output = pil2tensor(output)
-
-        return (output,)
+        return (pil2tensor(output),)


-class ImagePremultiply:
+class MTB_ImagePremultiply:
    """Premultiply image with mask"""

    @classmethod
@@ -591,7 +1022,7 @@ class ImagePremultiply:
        return (pil2tensor(out),)


-class ImageResizeFactor:
+class MTB_ImageResizeFactor:
    """Extracted mostly from WAS Node Suite, with a few edits (most notably multiple image support) and less features."""

    @classmethod
@@ -685,7 +1116,7 @@ class ImageResizeFactor:
        return (resized_image,)


-class SaveImageGrid_:
+class MTB_SaveImageGrid:
    """Save all the images in the input batch as a grid of images."""

    def __init__(self):
@@ -794,7 +1225,7 @@ class SaveImageGrid_:
        return {"ui": {"images": results}}


-class ImageTileOffset:
+class MTB_ImageTileOffset:
    """Mimics an old photoshop technique to check for seamless textures"""

    @classmethod
@@ -802,7 +1233,8 @@ class ImageTileOffset:
        return {
            "required": {
                "image": ("IMAGE",),
-                "tiles": ("INT", {"default": 2}),
+                "tilesX": ("INT", {"default": 2, "min": 1}),
+                "tilesY": ("INT", {"default": 2, "min": 1}),
            }
        }

@@ -812,17 +1244,19 @@ class ImageTileOffset:

    FUNCTION = "tile_image"

-    def tile_image(self, image: torch.Tensor, tiles: int = 2):
-        if tiles < 1:
+    def tile_image(
+        self, image: torch.Tensor, tilesX: int = 2, tilesY: int = 2
+    ):
+        if tilesX < 1 or tilesY < 1:
            raise ValueError("The number of tiles must be at least 1.")

        batch_size, height, width, channels = image.shape
-        tile_height = height // tiles
-        tile_width = width // tiles
+        tile_height = height // tilesY
+        tile_width = width // tilesX

        output_image = torch.zeros_like(image)

-        for i, j in itertools.product(range(tiles), range(tiles)):
+        for i, j in itertools.product(range(tilesY), range(tilesX)):
            start_h = i * tile_height
            end_h = start_h + tile_height
            start_w = j * tile_width
@@ -830,8 +1264,8 @@ class ImageTileOffset:

            tile = image[:, start_h:end_h, start_w:end_w, :]

-            output_start_h = (i + 1) % tiles * tile_height
-            output_start_w = (j + 1) % tiles * tile_width
+            output_start_h = (i + 1) % tilesY * tile_height
+            output_start_w = (j + 1) % tilesX * tile_width
            output_end_h = output_start_h + tile_height
            output_end_w = output_start_w + tile_width

@@ -843,16 +1277,19 @@ class ImageTileOffset:


 __nodes__ = [
-    ColorCorrect,
-    ImageCompare_,
-    ImageTileOffset,
-    Blur_,
+    MTB_ColorCorrect,
+    MTB_ColorCorrectGPU,
+    MTB_ImageCompare,
+    MTB_ImageTileOffset,
+    MTB_Blur,
    # DeglazeImage,
-    MaskToImage,
-    ColoredImage,
-    ImagePremultiply,
-    ImageResizeFactor,
-    SaveImageGrid_,
-    LoadImageFromUrl_,
-    Sharpen_,
+    MTB_MaskToImage,
+    MTB_ColoredImage,
+    MTB_ImagePremultiply,
+    MTB_ImageResizeFactor,
+    MTB_SaveImageGrid,
+    MTB_LoadImageFromUrl,
+    MTB_Sharpen,
+    MTB_ExtractCoordinatesFromImage,
+    MTB_CoordinatesToString,
 ]
@@ -1,8 +1,9 @@
 import torch
+
 from ..log import log


-class StackImages:
+class MTB_StackImages:
    """Stack the input images horizontally or vertically."""

    @classmethod
@@ -26,6 +27,11 @@ class StackImages:
        normalized_tensors = [
            self.normalize_to_rgba(tensor) for tensor in tensors
        ]
+        max_batch_size = max(tensor.shape[0] for tensor in normalized_tensors)
+        normalized_tensors = [
+            self.duplicate_frames(tensor, max_batch_size)
+            for tensor in normalized_tensors
+        ]

        if vertical:
            width = normalized_tensors[0].shape[2]
@@ -66,8 +72,23 @@ class StackImages:
                "expected 3 (RGB) or 4 (RGBA)."
            )

+    def duplicate_frames(self, tensor, target_batch_size):
+        """Duplicate frames in tensor to match the target batch size."""
+        current_batch_size = tensor.shape[0]
+        if current_batch_size < target_batch_size:
+            duplication_factors: int = target_batch_size // current_batch_size
+            duplicated_tensor = tensor.repeat(duplication_factors, 1, 1, 1)
+            remaining_frames = target_batch_size % current_batch_size
+            if remaining_frames > 0:
+                duplicated_tensor = torch.cat(
+                    (duplicated_tensor, tensor[:remaining_frames]), dim=0
+                )
+            return duplicated_tensor
+        else:
+            return tensor

-class PickFromBatch:
+
+class MTB_PickFromBatch:
    """Pick a specific number of images from a batch.

    either from the start or end.
@@ -106,4 +127,4 @@ class PickFromBatch:
        return (selected_tensors,)


-__nodes__ = [StackImages, PickFromBatch]
+__nodes__ = [MTB_StackImages, MTB_PickFromBatch]
@@ -21,7 +21,7 @@ def get_playlist_path(playlist_name: str, persistant_playlist=False):
    return output_dir / "playlists" / session_id / f"{playlist_name}.json"


-class ReadPlaylist:
+class MTB_ReadPlaylist:
    """Read a playlist"""

    @classmethod
@@ -62,7 +62,7 @@ class ReadPlaylist:
        return (json.loads(playlist_path.read_text(encoding="utf-8")),)


-class AddToPlaylist:
+class MTB_AddToPlaylist:
    """Add a video to the playlist"""

    @classmethod
@@ -116,7 +116,7 @@ class AddToPlaylist:
        return ()


-class ExportWithFfmpeg:
+class MTB_ExportWithFfmpeg:
    """Export with FFmpeg (Experimental)"""

    @classmethod
@@ -307,7 +307,7 @@ def prepare_animated_batch(


 # todo: deprecate for apng
-class SaveGif:
+class MTB_SaveGif:
    """Save the images from the batch as a GIF"""

    @classmethod
@@ -395,4 +395,9 @@ class SaveGif:
        return {"ui": {"gif": results}}


-__nodes__ = [SaveGif, ExportWithFfmpeg, AddToPlaylist, ReadPlaylist]
+__nodes__ = [
+    MTB_SaveGif,
+    MTB_ExportWithFfmpeg,
+    MTB_AddToPlaylist,
+    MTB_ReadPlaylist,
+]
@@ -1,7 +1,7 @@
 import torch


-class LatentLerp:
+class MTB_LatentLerp:
    """Linear interpolation (blend) between two latent vectors"""

    @classmethod
@@ -10,7 +10,10 @@ class LatentLerp:
            "required": {
                "A": ("LATENT",),
                "B": ("LATENT",),
-                "t": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "t": (
+                    "FLOAT",
+                    {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
            }
        }

@@ -29,5 +32,5 @@ class LatentLerp:


 __nodes__ = [
-    LatentLerp,
+    MTB_LatentLerp,
 ]
@@ -5,7 +5,7 @@ from rembg import remove
 from ..utils import pil2tensor, tensor2pil


-class ImageRemoveBackgroundRembg:
+class MTB_ImageRemoveBackgroundRembg:
    """Removes the background from the input using Rembg."""

    @classmethod
@@ -100,9 +100,13 @@ class ImageRemoveBackgroundRembg:

            pbar.update(1)

-        return (pil2tensor(out_img), pil2tensor(out_mask), pil2tensor(out_img_on_bg))
+        return (
+            pil2tensor(out_img),
+            pil2tensor(out_mask),
+            pil2tensor(out_img_on_bg),
+        )


 __nodes__ = [
-    ImageRemoveBackgroundRembg,
+    MTB_ImageRemoveBackgroundRembg,
 ]
@@ -1,11 +1,13 @@
 import copy

 import torch
+from torch.nn import functional as F
+from torch.nn.modules.utils import _pair

 from ..log import log


-class VaeDecode_:
+class MTB_VaeDecode:
    """Wrapper for the 2 core decoders but also adding the sd seamless hack, taken from: FlyingFireCo/tiled_ksampler"""

    @classmethod
@@ -29,7 +31,12 @@ class VaeDecode_:
    CATEGORY = "mtb/decode"

    def decode(
-        self, vae, samples, seamless_model, use_tiling_decoder=True, tile_size=512
+        self,
+        vae,
+        samples,
+        seamless_model,
+        use_tiling_decoder=True,
+        tile_size=512,
    ):
        if seamless_model:
            if use_tiling_decoder:
@@ -55,7 +62,25 @@ class VaeDecode_:
            return (vae.decode(samples["samples"]),)


-class ModelPatchSeamless:
+def conv_forward(lyr, tensor, weight, bias):
+    step = lyr.timestep
+    if (lyr.paddingStartStep < 0 or step >= lyr.paddingStartStep) and (
+        lyr.paddingStopStep < 0 or step <= lyr.paddingStopStep
+    ):
+        working = F.pad(tensor, lyr.paddingX, mode=lyr.padding_modeX)
+        working = F.pad(working, lyr.paddingY, mode=lyr.padding_modeY)
+    else:
+        working = F.pad(tensor, lyr.paddingX, mode="constant")
+        working = F.pad(working, lyr.paddingY, mode="constant")
+
+    lyr.timestep += 1
+
+    return F.conv2d(
+        working, weight, bias, lyr.stride, _pair(0), lyr.dilation, lyr.groups
+    )
+
+
+class MTB_ModelPatchSeamless:
    """Uses the stable diffusion 'hack' to infer seamless images by setting the model layers padding mode to circular (experimental)"""

    @classmethod
@@ -63,10 +88,16 @@ class ModelPatchSeamless:
        return {
            "required": {
                "model": ("MODEL",),
-                "tiling": (
+                "startStep": ("INT", {"default": 0}),
+                "stopStep": ("INT", {"default": 999}),
+                "tilingX": (
                    "BOOLEAN",
                    {"default": True},
-                ),  # kept for testing not sure why it should be false
+                ),
+                "tilingY": (
+                    "BOOLEAN",
+                    {"default": True},
+                ),
            }
        }

@@ -79,21 +110,46 @@ class ModelPatchSeamless:

    CATEGORY = "mtb/textures"

-    def apply_circular(self, model, enable):
+    def apply_circular(self, model, startStep, stopStep, x, y):
        for layer in [
-            layer for layer in model.modules() if isinstance(layer, torch.nn.Conv2d)
+            layer
+            for layer in model.modules()
+            if isinstance(layer, torch.nn.Conv2d)
        ]:
-            layer.padding_mode = "circular" if enable else "zeros"
+            layer.padding_modeX = "circular" if x else "constant"
+            layer.padding_modeY = "circular" if y else "constant"
+            layer.paddingX = (
+                layer._reversed_padding_repeated_twice[0],
+                layer._reversed_padding_repeated_twice[1],
+                0,
+                0,
+            )
+            layer.paddingY = (
+                0,
+                0,
+                layer._reversed_padding_repeated_twice[2],
+                layer._reversed_padding_repeated_twice[3],
+            )
+            layer.paddingStartStep = startStep
+            layer.paddingStopStep = stopStep
+            layer.timestep = 0
+            layer._conv_forward = conv_forward.__get__(layer, torch.nn.Conv2d)
+
        return model

    def hack(
        self,
        model,
-        tiling,
+        startStep,
+        stopStep,
+        tilingX,
+        tilingY,
    ):
        hacked_model = copy.deepcopy(model)
-        self.apply_circular(hacked_model.model, tiling)
+        self.apply_circular(
+            hacked_model.model, startStep, stopStep, tilingX, tilingY
+        )
        return (model, hacked_model)


-__nodes__ = [ModelPatchSeamless, VaeDecode_]
+__nodes__ = [MTB_ModelPatchSeamless, MTB_VaeDecode]
@@ -1,4 +1,4 @@
-class IntToBool:
+class MTB_IntToBool:
    """Basic int to bool conversion"""

    @classmethod
@@ -22,7 +22,7 @@ class IntToBool:
        return (bool(int),)


-class IntToNumber:
+class MTB_IntToNumber:
    """Node addon for the WAS Suite. Converts a "comfy" INT to a NUMBER."""

    @classmethod
@@ -50,7 +50,7 @@ class IntToNumber:
        return (int,)


-class FloatToNumber:
+class MTB_FloatToNumber:
    """Node addon for the WAS Suite. Converts a "comfy" FLOAT to a NUMBER."""

    @classmethod
@@ -77,11 +77,9 @@ class FloatToNumber:
    def float_to_number(self, float):
        return (float,)

-        return (int,)
-

 __nodes__ = [
-    FloatToNumber,
-    IntToBool,
-    IntToNumber,
+    MTB_FloatToNumber,
+    MTB_IntToBool,
+    MTB_IntToNumber,
 ]
@@ -0,0 +1,360 @@
+from pathlib import Path
+
+import safetensors.torch
+import torch
+import tqdm
+
+from ..log import log
+from ..utils import Operation, Precision
+from ..utils import output_dir as comfy_out_dir
+
+PRUNE_DATA = {
+    "known_junk_prefix": [
+        "embedding_manager.embedder.",
+        "lora_te_text_model",
+        "control_model.",
+    ],
+    "nai_keys": {
+        "cond_stage_model.transformer.embeddings.": "cond_stage_model.transformer.text_model.embeddings.",
+        "cond_stage_model.transformer.encoder.": "cond_stage_model.transformer.text_model.encoder.",
+        "cond_stage_model.transformer.final_layer_norm.": "cond_stage_model.transformer.text_model.final_layer_norm.",
+    },
+}
+
+# position_ids in clip is int64. model_ema.num_updates is int32
+dtypes_to_fp16 = {torch.float32, torch.float64, torch.bfloat16}
+dtypes_to_bf16 = {torch.float32, torch.float64, torch.float16}
+dtypes_to_fp8 = {torch.float32, torch.float64, torch.bfloat16, torch.float16}
+
+
+class MTB_ModelPruner:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "optional": {
+                "unet": ("MODEL",),
+                "clip": ("CLIP",),
+                "vae": ("VAE",),
+            },
+            "required": {
+                "save_separately": ("BOOLEAN", {"default": False}),
+                "save_folder": ("STRING", {"default": "checkpoints/ComfyUI"}),
+                "fix_clip": ("BOOLEAN", {"default": True}),
+                "remove_junk": ("BOOLEAN", {"default": True}),
+                "ema_mode": (
+                    ("disabled", "remove_ema", "ema_only"),
+                    {"default": "remove_ema"},
+                ),
+                "precision_unet": (
+                    Precision.list_members(),
+                    {"default": Precision.FULL.value},
+                ),
+                "operation_unet": (
+                    Operation.list_members(),
+                    {"default": Operation.CONVERT.value},
+                ),
+                "precision_clip": (
+                    Precision.list_members(),
+                    {"default": Precision.FULL.value},
+                ),
+                "operation_clip": (
+                    Operation.list_members(),
+                    {"default": Operation.CONVERT.value},
+                ),
+                "precision_vae": (
+                    Precision.list_members(),
+                    {"default": Precision.FULL.value},
+                ),
+                "operation_vae": (
+                    Operation.list_members(),
+                    {"default": Operation.CONVERT.value},
+                ),
+            },
+        }
+
+    OUTPUT_NODE = True
+    RETURN_TYPES = ()
+    CATEGORY = "mtb/prune"
+    FUNCTION = "prune"
+
+    def convert_precision(self, tensor: torch.Tensor, precision: Precision):
+        precision = Precision.from_str(precision)
+        log.debug(f"Converting to {precision}")
+        match precision:
+            case Precision.FP8:
+                if tensor.dtype in dtypes_to_fp8:
+                    return tensor.to(torch.float8_e4m3fn)
+                log.error(f"Cannot convert {tensor.dtype} to fp8")
+                return tensor
+            case Precision.FP16:
+                if tensor.dtype in dtypes_to_fp16:
+                    return tensor.half()
+                log.error(f"Cannot convert {tensor.dtype} to f16")
+                return tensor
+            case Precision.BF16:
+                if tensor.dtype in dtypes_to_bf16:
+                    return tensor.bfloat16()
+                log.error(f"Cannot convert {tensor.dtype} to bf16")
+                return tensor
+            case Precision.FULL | Precision.FP32:
+                return tensor
+
+    def is_sdxl_model(self, clip: dict[str, torch.Tensor] | None):
+        if clip:
+            return (any(k.startswith("conditioner.embedders") for k in clip),)
+        return False
+
+    def has_ema(self, unet: dict[str, torch.Tensor]):
+        return any(k.startswith("model_ema") for k in unet)
+
+    def fix_clip(self, clip: dict[str, torch.Tensor] | None):
+        if self.is_sdxl_model(clip):
+            log.warn("[fix clip] SDXL not supported")
+            return
+
+        if clip is None:
+            return
+
+        position_id_key = (
+            "cond_stage_model.transformer.text_model.embeddings.position_ids"
+        )
+        if position_id_key in clip:
+            correct = torch.Tensor([list(range(77))]).to(torch.int64)
+            now = clip[position_id_key].to(torch.int64)
+
+            broken = correct.ne(now)
+            broken = [i for i in range(77) if broken[0][i]]
+
+            if len(broken) != 0:
+                clip[position_id_key] = correct
+                log.info(f"[Converter] Fixed broken clip\n{broken}")
+            else:
+                log.info(
+                    "[Converter] Clip in this model is fine, skip fixing..."
+                )
+
+        else:
+            log.info("[Converter] Missing position id in model, try fixing...")
+            clip[position_id_key] = torch.Tensor([list(range(77))]).to(
+                torch.int64
+            )
+        return clip
+
+    def get_dicts(self, unet, clip, vae):
+        clip_sd = clip.get_sd()
+        state_dict = unet.model.state_dict_for_saving(
+            clip_sd, vae.get_sd(), None
+        )
+
+        unet = {
+            k: v
+            for k, v in state_dict.items()
+            if k.startswith("model.diffusion_model")
+        }
+        clip = {
+            k: v
+            for k, v in state_dict.items()
+            if k.startswith("cond_stage_model")
+            or k.startswith("conditioner.embedders")
+        }
+        vae = {
+            k: v
+            for k, v in state_dict.items()
+            if k.startswith("first_stage_model")
+        }
+
+        other = {
+            k: v
+            for k, v in state_dict.items()
+            if k not in unet and k not in vae and k not in clip
+        }
+
+        return (unet, clip, vae, other)
+
+    def do_remove_junk(self, tensors: dict[str, dict[str, torch.Tensor]]):
+        need_delete: list[str] = []
+        for layer in tensors:
+            for key in layer:
+                for jk in PRUNE_DATA["known_junk_prefix"]:
+                    if key.startswith(jk):
+                        need_delete.append(".".join([layer, key]))
+
+        for k in need_delete:
+            log.info(f"Removing junk data: {k}")
+            del tensors[k]
+
+        return tensors
+
+    def prune(
+        self,
+        *,
+        save_separately: bool,
+        save_folder: str,
+        fix_clip: bool,
+        remove_junk: bool,
+        ema_mode: str,
+        precision_unet: Precision,
+        precision_clip: Precision,
+        precision_vae: Precision,
+        operation_unet: str,
+        operation_clip: str,
+        operation_vae: str,
+        unet: dict[str, torch.Tensor] | None = None,
+        clip: dict[str, torch.Tensor] | None = None,
+        vae: dict[str, torch.Tensor] | None = None,
+    ):
+        operation = {
+            "unet": Operation.from_str(operation_unet),
+            "clip": Operation.from_str(operation_clip),
+            "vae": Operation.from_str(operation_vae),
+        }
+        precision = {
+            "unet": Precision.from_str(precision_unet),
+            "clip": Precision.from_str(precision_clip),
+            "vae": Precision.from_str(precision_vae),
+        }
+
+        unet, clip, vae, _other = self.get_dicts(unet, clip, vae)
+
+        out_dir = Path(save_folder)
+        folder = out_dir.parent
+        if not out_dir.is_absolute():
+            folder = (comfy_out_dir / save_folder).parent
+
+        if not folder.exists():
+            if folder.parent.exists():
+                folder.mkdir()
+            else:
+                raise FileNotFoundError(
+                    f"Folder {folder.parent} does not exist"
+                )
+
+        name = out_dir.name
+        save_name = f"{name}-{precision_unet}"
+        if ema_mode != "disabled":
+            save_name += f"-{ema_mode}"
+        if fix_clip:
+            save_name += "-clip-fix"
+
+        if (
+            any(o == Operation.CONVERT for o in operation.values())
+            and any(p == Precision.FP8 for p in precision.values())
+            and torch.__version__ < "2.1.0"
+        ):
+            raise NotImplementedError(
+                "PyTorch 2.1.0 or newer is required for fp8 conversion"
+            )
+
+        if not self.is_sdxl_model(clip):
+            for part in [unet, vae, clip]:
+                if part:
+                    nai_keys = PRUNE_DATA["nai_keys"]
+                    for k in list(part.keys()):
+                        for r in nai_keys:
+                            if isinstance(k, str) and k.startswith(r):
+                                new_key = k.replace(r, nai_keys[r])
+                                part[new_key] = part[k]
+                                del part[k]
+                                log.info(
+                                    f"[Converter] Fixed novelai error key {k}"
+                                )
+                                break
+
+            if fix_clip:
+                clip = self.fix_clip(clip)
+
+        ok: dict[str, dict[str, torch.Tensor]] = {
+            "unet": {},
+            "clip": {},
+            "vae": {},
+        }
+
+        def _hf(part: str, wk: str, t: torch.Tensor):
+            if not isinstance(t, torch.Tensor):
+                log.debug("Not a torch tensor, skipping key")
+                return
+
+            log.debug(f"Operation {operation[part]}")
+            if operation[part] == Operation.CONVERT:
+                ok[part][wk] = self.convert_precision(
+                    t, precision[part]
+                )  # conv_func(t)
+            elif operation[part] == Operation.COPY:
+                ok[part][wk] = t
+            elif operation[part] == Operation.DELETE:
+                return
+
+        log.info("[Converter] Converting model...")
+
+        for part_name, part in zip(
+            ["unet", "vae", "clip", "other"],
+            [unet, vae, clip],
+            strict=False,
+        ):
+            if part:
+                match ema_mode:
+                    case "remove_ema":
+                        for k, v in tqdm.tqdm(part.items()):
+                            if "model_ema." not in k:
+                                _hf(part_name, k, v)
+                    case "ema_only":
+                        if not self.has_ema(part):
+                            log.warn("No EMA to extract")
+                            return
+                        for k in tqdm.tqdm(part):
+                            ema_k = "___"
+                            try:
+                                ema_k = "model_ema." + k[6:].replace(".", "")
+                            except Exception:
+                                pass
+                            if ema_k in part:
+                                _hf(part_name, k, part[ema_k])
+                            elif not k.startswith("model_ema.") or k in [
+                                "model_ema.num_updates",
+                                "model_ema.decay",
+                            ]:
+                                _hf(part_name, k, part[k])
+                    case "disabled" | _:
+                        for k, v in tqdm.tqdm(part.items()):
+                            _hf(part_name, k, v)
+
+                if save_separately:
+                    if remove_junk:
+                        ok = self.do_remove_junk(ok)
+
+                    flat_ok = {
+                        k: v
+                        for _, subdict in ok.items()
+                        for k, v in subdict.items()
+                    }
+                    save_path = (
+                        folder / f"{part_name}-{save_name}.safetensors"
+                    ).as_posix()
+                    safetensors.torch.save_file(flat_ok, save_path)
+                    ok: dict[str, dict[str, torch.Tensor]] = {
+                        "unet": {},
+                        "clip": {},
+                        "vae": {},
+                    }
+
+        if save_separately:
+            return ()
+
+        if remove_junk:
+            ok = self.do_remove_junk(ok)
+
+        flat_ok = {
+            k: v for _, subdict in ok.items() for k, v in subdict.items()
+        }
+
+        try:
+            safetensors.torch.save_file(
+                flat_ok, (folder / f"{save_name}.safetensors").as_posix()
+            )
+        except Exception as e:
+            log.error(e)
+
+        return ()
+
+
+__nodes__ = [MTB_ModelPruner]
@@ -0,0 +1,85 @@
+import qrcode
+import torch
+from PIL import Image
+
+from ..log import log
+from ..utils import pil2tensor
+
+
+class MTB_QrCode:
+    """Basic QR Code generator."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "url": ("STRING", {"default": "https://www.github.com"}),
+                "width": (
+                    "INT",
+                    {"default": 256, "max": 8096, "min": 0, "step": 1},
+                ),
+                "height": (
+                    "INT",
+                    {"default": 256, "max": 8096, "min": 0, "step": 1},
+                ),
+                "error_correct": (("L", "M", "Q", "H"), {"default": "L"}),
+                "box_size": (
+                    "INT",
+                    {"default": 10, "max": 8096, "min": 0, "step": 1},
+                ),
+                "border": (
+                    "INT",
+                    {"default": 4, "max": 8096, "min": 0, "step": 1},
+                ),
+                "invert": (("BOOLEAN",), {"default": False}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "do_qr"
+    CATEGORY = "mtb/generate"
+
+    def do_qr(
+        self,
+        *,
+        url: str,
+        width: int,
+        height: int,
+        error_correct: str,
+        box_size: int,
+        border: int,
+        invert: bool,
+    ) -> tuple[torch.Tensor]:
+        log.warning(
+            "This node will soon be deprecated, there are much better alternatives like https://github.com/coreyryanhanson/comfy-qr"
+        )
+        if error_correct == "L" or error_correct not in ["M", "Q", "H"]:
+            error_correct = qrcode.constants.ERROR_CORRECT_L
+        elif error_correct == "M":
+            error_correct = qrcode.constants.ERROR_CORRECT_M
+        elif error_correct == "Q":
+            error_correct = qrcode.constants.ERROR_CORRECT_Q
+        else:
+            error_correct = qrcode.constants.ERROR_CORRECT_H
+
+        qr = qrcode.QRCode(
+            version=1,
+            error_correction=error_correct,
+            box_size=box_size,
+            border=border,
+        )
+        qr.add_data(url)
+        qr.make(fit=True)
+
+        back_color = (255, 255, 255) if invert else (0, 0, 0)
+        fill_color = (0, 0, 0) if invert else (255, 255, 255)
+
+        code = qr.make_image(back_color=back_color, fill_color=fill_color)
+
+        # that we now resize without filtering
+        code = code.resize((width, height), Image.NEAREST)
+
+        return (pil2tensor(code),)
+
+
+__nodes__ = [MTB_QrCode]
@@ -1,15 +1,16 @@
+from math import ceil, sqrt
+from typing import cast
+
 import torch
 import torchvision.transforms.functional as TF
-from ..utils import log, hex_to_rgb, tensor2pil, pil2tensor
-from math import sqrt, ceil
-from typing import cast
 from PIL import Image

+from ..utils import hex_to_rgb, log, pil2tensor, tensor2pil

-class TransformImage:
+
+class MTB_TransformImage:
    """Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy

-
    it return a tensor representing the transformed images with the same shape as the input tensor
    """

@@ -18,10 +19,22 @@ class TransformImage:
        return {
            "required": {
                "image": ("IMAGE",),
-                "x": ("FLOAT", {"default": 0, "step": 1, "min": -4096, "max": 4096}),
-                "y": ("FLOAT", {"default": 0, "step": 1, "min": -4096, "max": 4096}),
-                "zoom": ("FLOAT", {"default": 1.0, "min": 0.001, "step": 0.01}),
-                "angle": ("FLOAT", {"default": 0, "step": 1, "min": -360, "max": 360}),
+                "x": (
+                    "FLOAT",
+                    {"default": 0, "step": 1, "min": -4096, "max": 4096},
+                ),
+                "y": (
+                    "FLOAT",
+                    {"default": 0, "step": 1, "min": -4096, "max": 4096},
+                ),
+                "zoom": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.001, "step": 0.01},
+                ),
+                "angle": (
+                    "FLOAT",
+                    {"default": 0, "step": 1, "min": -360, "max": 360},
+                ),
                "shear": (
                    "FLOAT",
                    {"default": 0, "step": 1, "min": -4096, "max": 4096},
@@ -53,14 +66,21 @@ class TransformImage:
        y = int(y)
        angle = int(angle)

-        log.debug(f"Zoom: {zoom} | x: {x}, y: {y}, angle: {angle}, shear: {shear}")
+        log.debug(
+            f"Zoom: {zoom} | x: {x}, y: {y}, angle: {angle}, shear: {shear}"
+        )

        if image.size(0) == 0:
            return (torch.zeros(0),)
        transformed_images = []
-        frames_count, frame_height, frame_width, frame_channel_count = image.size()
+        frames_count, frame_height, frame_width, frame_channel_count = (
+            image.size()
+        )

-        new_height, new_width = int(frame_height * zoom), int(frame_width * zoom)
+        new_height, new_width = (
+            int(frame_height * zoom),
+            int(frame_width * zoom),
+        )

        log.debug(f"New height: {new_height}, New width: {new_width}")

@@ -74,7 +94,12 @@ class TransformImage:
        pw += abs(max_padding)
        ph += abs(max_padding)

-        padding = [max(0, pw + x), max(0, ph + y), max(0, pw - x), max(0, ph - y)]
+        padding = [
+            max(0, pw + x),
+            max(0, ph + y),
+            max(0, pw - x),
+            max(0, ph - y),
+        ]

        constant_color = hex_to_rgb(constant_color)
        log.debug(f"Fill Tuple: {constant_color}")
@@ -89,7 +114,9 @@ class TransformImage:

            img = cast(
                Image.Image,
-                TF.affine(img, angle=angle, scale=zoom, translate=[x, y], shear=shear),
+                TF.affine(
+                    img, angle=angle, scale=zoom, translate=[x, y], shear=shear
+                ),
            )

            left = abs(padding[0])
@@ -107,4 +134,4 @@ class TransformImage:
        return (pil2tensor(transformed_images),)


-__nodes__ = [TransformImage]
+__nodes__ = [MTB_TransformImage]
@@ -1,4 +1,7 @@
-import hashlib, json, os, re
+import hashlib
+import json
+import os
+import re
 from pathlib import Path

 import folder_paths
@@ -10,11 +13,12 @@ from PIL.PngImagePlugin import PngInfo
 from ..log import log


-class LoadImageSequence:
+class MTB_LoadImageSequence:
    """Load an image sequence from a folder. The current frame is used to determine which image to load.

    Usually used in conjunction with the `Primitive` node set to increment to load a sequence of images from a folder.
    Use -1 to load all matching frames as a batch.
+
    """

    @classmethod
@@ -26,7 +30,10 @@ class LoadImageSequence:
                    "INT",
                    {"default": 0, "min": -1, "max": 9999999},
                ),
-            }
+            },
+            "optional": {
+                "range": ("STRING", {"default": ""}),
+            },
        }

    CATEGORY = "mtb/IO"
@@ -35,17 +42,28 @@ class LoadImageSequence:
        "IMAGE",
        "MASK",
        "INT",
+        "INT",
    )
    RETURN_NAMES = (
        "image",
        "mask",
        "current_frame",
+        "total_frames",
    )

-    def load_image(self, path=None, current_frame=0):
+    def load_image(self, path=None, current_frame=0, range=""):
        load_all = current_frame == -1
+        total_frames = 1

-        if load_all:
+        if range:
+            frames = self.get_frames_from_range(path, range)
+            imgs, masks = zip(*(img_from_path(frame) for frame in frames))
+            out_img = torch.cat(imgs, dim=0)
+            out_mask = torch.cat(masks, dim=0)
+            total_frames = len(imgs)
+            return (out_img, out_mask, -1, total_frames)
+
+        elif load_all:
            log.debug(f"Loading all frames from {path}")
            frames = resolve_all_frames(path)
            log.debug(f"Found {len(frames)} frames")
@@ -53,33 +71,72 @@ class LoadImageSequence:
            imgs = []
            masks = []

-            for frame in frames:
-                img, mask = img_from_path(frame)
-                imgs.append(img)
-                masks.append(mask)
+            imgs, masks = zip(*(img_from_path(frame) for frame in frames))

            out_img = torch.cat(imgs, dim=0)
            out_mask = torch.cat(masks, dim=0)
+            total_frames = len(imgs)

-            return (
-                out_img,
-                out_mask,
-            )
+            return (out_img, out_mask, -1, total_frames)

        log.debug(f"Loading image: {path}, {current_frame}")
-        print(f"Loading image: {path}, {current_frame}")
        resolved_path = resolve_path(path, current_frame)
        image_path = folder_paths.get_annotated_filepath(resolved_path)
        image, mask = img_from_path(image_path)
-        return (
-            image,
-            mask,
-            current_frame,
-        )
+        return (image, mask, current_frame, total_frames)
+
+    def get_frames_from_range(self, path, range_str):
+        try:
+            start, end = map(int, range_str.split("-"))
+        except ValueError:
+            raise ValueError(
+                f"Invalid range format: {range_str}. Expected format is 'start-end'."
+            )
+
+        frames = resolve_all_frames(path)
+        total_frames = len(frames)
+
+        if start < 0 or end >= total_frames:
+            raise ValueError(
+                f"Range {range_str} is out of bounds. Total frames available: {total_frames}"
+            )
+
+        if "#" in path:
+            frame_regex = re.escape(path).replace(r"\#", r"(\d+)")
+            frame_number_regex = re.compile(frame_regex)
+
+            matching_frames = []
+            for frame in frames:
+                match = frame_number_regex.search(frame)
+
+                if match:
+                    frame_number = int(match.group(1))
+                    if start <= frame_number <= end:
+                        matching_frames.append(frame)
+
+            return matching_frames
+        else:
+            log.warning(
+                f"Wildcard pattern or directory will use indexes instead of frame numbers for : {path}"
+            )
+
+            selected_frames = frames[start : end + 1]
+
+        return selected_frames

    @staticmethod
-    def IS_CHANGED(path="", current_frame=0):
+    def IS_CHANGED(path="", current_frame=0, range=""):
        print(f"Checking if changed: {path}, {current_frame}")
+        if range or current_frame == -1:
+            resolved_paths = resolve_all_frames(path)
+            timestamps = [
+                os.path.getmtime(folder_paths.get_annotated_filepath(p))
+                for p in resolved_paths
+            ]
+            combined_hash = hashlib.sha256(
+                "".join(map(str, timestamps)).encode()
+            )
+            return combined_hash.hexdigest()
        resolved_path = resolve_path(path, current_frame)
        image_path = folder_paths.get_annotated_filepath(resolved_path)
        if os.path.exists(image_path):
@@ -119,11 +176,28 @@ def img_from_path(path):
    )


-def resolve_all_frames(pattern):
+def resolve_all_frames(path: str):
+    frames: list[str] = []
+    if "#" not in path:
+        pth = Path(path)
+        if pth.is_dir():
+            for f in pth.iterdir():
+                if f.suffix in [".jpg", ".png"]:
+                    frames.append(f.as_posix())
+        elif "*" in path:
+            frames = glob.glob(path)
+        else:
+            raise ValueError(
+                "The path doesn't contain a # or a * or is not a directory"
+            )
+        frames.sort()
+
+        return frames
+
+    pattern = path
    folder_path, file_pattern = os.path.split(pattern)

    log.debug(f"Resolving all frames in {folder_path}")
-    frames = []
    hash_count = file_pattern.count("#")
    frame_pattern = re.sub(r"#+", "*", file_pattern)

@@ -155,7 +229,7 @@ def resolve_path(path, frame):
    return re.sub("#+", padded_number, path)


-class SaveImageSequence:
+class MTB_SaveImageSequence:
    """Save an image sequence to a folder. The current frame is used to determine which image to save.

    This is merely a wrapper around the `save_images` function with formatting for the output folder and filename.
@@ -251,6 +325,6 @@ class SaveImageSequence:


 __nodes__ = [
-    LoadImageSequence,
-    SaveImageSequence,
+    MTB_LoadImageSequence,
+    MTB_SaveImageSequence,
 ]
@@ -0,0 +1,141 @@
+import cv2
+import numpy as np
+import torch
+from huggingface_hub import hf_hub_download
+
+from ..utils import models_dir, np2tensor
+
+# TODO: check if I can make a torch script device independant
+# for now I forced it to use cuda.
+
+
+class MTB_LoadVitMatteModel:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "kind": (("Composition-1K", "Distinctions-646"),),
+                "autodownload": ("BOOLEAN", {"default": True}),
+            },
+        }
+
+    RETURN_TYPES = ("VITMATTE_MODEL",)
+    RETURN_NAMES = ("torch_script",)
+    CATEGORY = "mtb/vitmatte"
+    FUNCTION = "execute"
+
+    def execute(self, *, kind: str, autodownload: bool):
+        dest = models_dir / "vitmatte"
+        dest.mkdir(exist_ok=True)
+        name = "dist" if kind == "Distinctions-646" else "com"
+
+        file = hf_hub_download(
+            repo_id="melmass/pytorch-scripts",
+            filename=f"vitmatte_b_{name}.pt",
+            local_dir=dest.as_posix(),
+            local_files_only=not autodownload,
+        )
+        model = torch.jit.load(file).to("cuda")
+
+        return (model,)
+
+
+class MTB_GenerateTrimap:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                # "image": ("IMAGE",),
+                "mask": ("MASK",),
+                "erode": ("INT", {"default": 10}),
+                "dilate": ("INT", {"default": 10}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("trimap",)
+
+    CATEGORY = "mtb/vitmatte"
+    FUNCTION = "execute"
+
+    def execute(
+        self,
+        # image:torch.Tensor,
+        mask: torch.Tensor,
+        erode: int = 10,
+        dilate: int = 10,
+    ):
+        # TODO: not sure what's the most practical between IMAGE or MASK
+
+        # image = image.to("cuda").half()
+        mask = mask.to("cuda").half()
+
+        trimaps = []
+        for m in mask:
+            mask_arr = m.squeeze(0).to(torch.uint8).cpu().numpy() * 255
+            erode_kernel = np.ones((erode, erode), np.uint8)
+            dilate_kernel = np.ones((dilate, dilate), np.uint8)
+            eroded = cv2.erode(mask_arr, erode_kernel, iterations=5)
+            dilated = cv2.dilate(mask_arr, dilate_kernel, iterations=5)
+            trimap = np.zeros_like(mask_arr)
+            trimap[dilated == 255] = 128
+            trimap[eroded == 255] = 255
+            trimaps.append(trimap)
+
+        return (np2tensor(trimaps),)
+
+
+class MTB_ApplyVitMatte:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model": ("VITMATTE_MODEL",),
+                "image": ("IMAGE",),
+                "trimap": ("IMAGE",),
+                "returns": (("RGB", "RGBA"),),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("image (rgba)", "mask")
+    CATEGORY = "mtb/utils"
+    FUNCTION = "execute"
+
+    def execute(
+        self, model, image: torch.Tensor, trimap: torch.Tensor, returns: str
+    ):
+        im_count = image.shape[0]
+        tm_count = trimap.shape[0]
+
+        if im_count != tm_count:
+            raise ValueError("image and trimap must have the same batch size")
+
+        outputs_m: list[torch.Tensor] = []
+        outputs_i: list[torch.Tensor] = []
+        for i, im in enumerate(image):
+            tm = trimap[i].half().unsqueeze(2).permute(2, 0, 1).to("cuda")
+            im = im.half().permute(2, 0, 1).to("cuda")
+
+            inputs = {"image": im.unsqueeze(0), "trimap": tm.unsqueeze(0)}
+
+            fine_mask = model(inputs)
+            foreground = im * fine_mask + (1 - fine_mask)
+
+            if returns == "RGBA":
+                rgba_image = torch.cat(
+                    (foreground, fine_mask.unsqueeze(0)), dim=0
+                )
+                outputs_i.append(rgba_image.unsqueeze(0))
+            else:
+                outputs_i.append(foreground.unsqueeze(0))
+
+            outputs_m.append(fine_mask.unsqueeze(0))
+
+        result_m = torch.cat(outputs_m, dim=0)
+        result_i = torch.cat(outputs_i, dim=0)
+
+        return (result_i.permute(0, 2, 3, 1), result_m)
+
+
+__nodes__ = [MTB_LoadVitMatteModel, MTB_GenerateTrimap, MTB_ApplyVitMatte]
@@ -1,114 +1,179 @@
-[tool.poetry]
-name = "comfy-mtb"
-version = "0.4.0"
-description = "Animation oriented nodes pack for ComfyUI."
-license = "MIT"
-readme = "README.md"
-repository = "https://github.com/melMass/comfy_mtb"
-authors = ["Mel Massadian"]
-packages = [{ include = "comfy-mtb" }]
-classifiers = [
-  "License :: OSI Approved :: MIT License",
-  "Operating System :: OS Independent",
-  "Programming Language :: Python",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Intended Audience :: Developers",
-]
-
-[tool.poetry.urls]
-"Bug Tracker" = "https://github.com/melMass/comfy_mtb/issues"
-"Changelog" = "https://github.com/melMass/comfy_mtb/releases"
-
-[tool.poetry.dependencies]
-python = "^3.10"
-
-[tool.poetry.group.dev.dependencies]
-black = { extras = ["jupyter"], version = "^23.7.0" }
-codespell = "^2.2.5"
-mypy = "^1.5.1"
-pre-commit = "^3.3.3"
-pytest = "^7.4.0"
-pytest-cov = "^4.1.0"
-pytest-random-order = "^1.1.0"
-ruff = "^0.0.285"
-
-[tool.poetry.group.docs]
-optional = true
-
-[tool.poetry.group.docs.dependencies]
-docutils = "0.17.1"
-jupyter-book = "^0.15.1"
-sphinx-autobuild = "^2021.3.14"
-
-[tool.pytest.ini_options]
-log_level = "DEBUG"
-log_cli = true
-markers = [
-  "wip: tests that aren't fully finished yet",
-  "heavy: marks tests as heavy (deselect with '-m \"not heavy\"')",
-
-]
-filterwarnings = ["ignore::UserWarning", 'ignore::DeprecationWarning']
-
-[tool.isort]
-profile = "black"
-line_length = 88
-auto_identify_namespace_packages = false
-# NOTE:
-# pyright doesn't like implicit namespace + single line (related to https://github.com/microsoft/pyright/issues/2882?) but it's horible so I'll live with it
-force_single_line = false
-known_first_party = ["mtb"]
-extend_skip = ["archives"]
-combine_straight_imports = true
-
-[tool.coverage.run]
-parallel = true
-source = ["docs", "tests", "comfy-mtb"]
-
-[tool.coverage.report]
-fail_under = 90
-show_missing = true
-
-[tool.coverage.html]
-show_contexts = true
-
-[tool.ruff]
-line-length = 79
-select = ["A", "B", "C", "D", "E", "F", "FBT", "I", "N", "S", "SIM", "UP", "W"]
-# NOTE: 
-# D102 - undocumented-public-method (noisy)
-# D103 - undocumented-public-function (noisy)
-# D100 - undocumented-public-module (noisy)
-# N802 - invalid-function-name (forced by comfy's arch)
-ignore = ["D103", "D102", "D100", "N802"]
-# exclude auto generated file
-extend-exclude = ["./docs/conf.py"]
-
-[tool.ruff.per-file-ignores]
-# imported but unused
-"__init__.py" = ["F401"]
-# use of assert detected
-"tests/*" = ["S101"]
-
-[tool.ruff.pydocstyle]
-convention = "numpy"
-
-[tool.mypy]
-pretty = true
-ignore_missing_imports = true
-# exclude auto generated file
-exclude = ["docs/conf.py"]
-
-[tool.codespell]
-# exclude auto generated file
-skip = "./docs/conf.py,poetry.lock"
-check-filenames = true
-
-[tool.poetry-version-plugin]
-source = "git-tag"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "comfy-mtb"
+version = "0.1.6"
+description = "Animation oriented nodes pack for ComfyUI."
+license = "MIT"
+readme = "README.md"
+# repository = ""
+# url = "https://github.com/melMass/comfy_mtb"
+authors = [{ name = "Mel Massadian", email = "mel@melmassadian.com" }]
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Intended Audience :: Developers",
+]
+requires-python = ">=3.10"
+dependencies = [
+  "qrcode",
+  "onnxruntime-gpu",
+  "requirements-parserx",
+  "rembg",
+  "imageio_ffmpeg",
+  "rich",
+  "rich_argparse",
+  "matplotlib",
+  "pillow",
+]
+optional-dependencies = { mel = [
+  "jupyterlab==4.1.6",
+], dev = [
+  "black[jupyter]",
+  "codespell",
+  "mypy",
+  "pre-commit",
+  "pytest",
+  "pytest-cov",
+  "pytest-random-order",
+  "ruff",
+], doc = [
+  "docutils==0.17.1",
+  "jupyter-book>=0.15",
+  "sphinx-autobuild",
+] }
+
+[project.urls]
+Homepage = "https://github.com/melMass/comfy_mtb"
+Documentation = "https://github.com/melMass/comfy_mtb/wiki"
+Repository = "https://github.com/melMass/comfy_mtb"
+Issues = "https://github.com/melMass/comfy_mtb/issues"
+
+[tool.comfy]
+PublisherId = "mel"
+DisplayName = "comfy-mtb"
+Icon = "https://avatars.githubusercontent.com/u/7041726?v=4"
+
+[tool.bumpversion]
+current_version = "0.1.6"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = true
+tag_name = "v{new_version}"
+tag_message = "⬆️ Bump version: {current_version} → {new_version}"
+allow_dirty = true
+commit = true
+message = "⬆️ Bump version: {current_version} → {new_version}"
+commit_args = ""
+
+[[tool.bumpversion.files]]
+filename = "__init__.py"
+search = "__version__ = \"{current_version}\""
+replace = "__version__ = \"{new_version}\""
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = "version = \"{current_version}\""
+replace = "version = \"{new_version}\""
+
+# [[tool.bumpversion.files]]
+# filename = "your_package/__init__.py"
+# search = "__version__ = '{current_version}'"
+# replace = "__version__ = '{new_version}'"
+
+# INFO: All those remaining keys are meant for local dev
+[tool.pyright]
+include = ["."]
+exclude = [
+  "**/node_modules",
+  "**/__pycache__",
+  "src/experimental",
+  "src/typestubs",
+]
+ignore = ["src/oldstuff"]
+defineConstant = { DEBUG = true }
+extraPaths = ["python", "../.."]
+stubPath = "src/stubs"
+
+reportMissingImports = true
+reportMissingTypeStubs = false
+typeCheckingMode = "basic"
+
+pythonVersion = "3.10"
+pythonPlatform = "Windows"
+
+[tool.pytest.ini_options]
+log_level = "DEBUG"
+log_cli = true
+markers = [
+  "wip: tests that aren't fully finished yet",
+  "heavy: marks tests as heavy (deselect with '-m \"not heavy\"')",
+
+]
+filterwarnings = ["ignore::UserWarning", 'ignore::DeprecationWarning']
+
+[tool.isort]
+profile = "black"
+line_length = 88
+auto_identify_namespace_packages = false
+# NOTE:
+# pyright doesn't like implicit namespace + single line (related to https://github.com/microsoft/pyright/issues/2882?) but it's horible so I'll live with it
+force_single_line = false
+known_first_party = ["mtb"]
+extend_skip = ["archives"]
+combine_straight_imports = true
+
+[tool.coverage.run]
+parallel = true
+source = ["docs", "tests", "comfy-mtb"]
+
+[tool.coverage.report]
+fail_under = 90
+show_missing = true
+
+[tool.coverage.html]
+show_contexts = true
+
+[tool.ruff]
+line-length = 79
+select = ["A", "B", "C", "D", "E", "F", "FBT", "I", "N", "S", "SIM", "UP", "W"]
+# NOTE:
+# D102 - undocumented-public-method (noisy)
+# D103 - undocumented-public-function (noisy)
+# D100 - undocumented-public-module (noisy)
+# N802 - invalid-function-name (forced by comfy's arch)
+ignore = ["D103", "D102", "D100", "N802"]
+# exclude auto generated file
+extend-exclude = ["./docs/conf.py"]
+
+[tool.ruff.per-file-ignores]
+# imported but unused
+"__init__.py" = ["F401"]
+# use of assert detected
+"tests/*" = ["S101"]
+
+[tool.ruff.pydocstyle]
+convention = "numpy"
+
+[tool.mypy]
+pretty = true
+ignore_missing_imports = true
+# exclude auto generated file
+exclude = ["docs/conf.py"]
+
+[tool.codespell]
+# exclude auto generated file
+skip = "./docs/conf.py,poetry.lock"
+check-filenames = true
@@ -0,0 +1,126 @@
+// Some manual types I use to facilitate developing on top of
+// Comfy's Litegraph implementation.
+
+import type {
+  ContextMenuItem,
+  LGraphNode,
+  IWidget,
+  LGraph,
+} from '../../../web/types/litegraph'
+
+export type {
+  ComfyExtension,
+  ComfyObjectInfo,
+  ComfyObjectInfoConfig,
+} from '../../../web/types/comfy'
+
+export type {
+  ContextMenuItem,
+  IWidget,
+  LLink,
+  INodeInputSlot,
+  INodeOutputSlot,
+} from '../../../web/types/litegraph'
+
+export type VectorWidget = IWidget<number[], { default: number[] }>
+export interface NodeData {
+  category: str
+  description: str
+  display_name: str
+  input: NodeInput
+  name: str
+  output: [str]
+  output_is_list: [boolean]
+  output_name: [str]
+  output_node: boolean
+}
+
+export interface ComfyDialog {
+  element: Element
+  close: () => void
+  show: (html: str) => void
+}
+
+export interface ComfySettingsDialog {
+  app: ComfyApp
+  element: Element
+  settingsValues: Record<string, unknown>
+  settingsLookup: Record<string, unknown>
+  load: () => Promise<void>
+  setSettingValueAsync: (id: string, value: unknown) => Promise<void>
+}
+
+export interface ComfyUI {
+  app: ComfyApp
+  dialog: ComfyDialog
+  settings: ComfySettingsDialog
+  autoQueueMode: 'instant' | 'change'
+  batchCount: number
+  lastQueueSize: number
+  graphHasChanged: boolean
+  queue: ComfyList
+  history: ComfyList
+}
+
+/**Very incomplete Comfy App definition*/
+interface ComfyApp {
+  graph: LGraph
+  queueItems: { number: number; batchCount: number }[]
+  processingQueue: boolean
+  ui: ComfyUI
+  extensions: ComfyExtension[]
+  nodeOutputs: Record<string, unknown>
+  nodePreviewImages: Record<string, Image>
+  shiftDown: boolean
+  isImageNode: (node: LGraphNodeExtended) => boolean
+  queuePrompt: (number: number, batchCount: number) => Promise<void>
+  /** Loads workflow data from the specified file*/
+  handleFile: (file: File) => Promise<void>
+}
+
+export type { ComfyApp as App }
+
+export interface LGraphNodeExtension {
+  addDOMWidget: (
+    name: string,
+    type: string,
+    element: Element,
+    options: Record<string, unknown>,
+  ) => IWidget
+  onNodeCreated: () => void
+  getExtraMenuOptions: () => ContextMenuItem[]
+  prototype: LGraphNodeExtended
+}
+
+export type LGraphNodeExtended = LGraphNode & LGraphNodeExtension
+
+export interface NodeType /*extends LGraphNode*/ {
+  category: str
+  comfyClass: str
+  length: 0
+  name: str
+  nodeData: NodeData
+  prototype: LGraphNodeExtended
+  title: str
+  type: str
+}
+
+export interface NodeInput {
+  required: object
+}
+
+// NOTE: for prototype overriding
+export type OnDrawWidgetParams = Parameters<IWidget['draw']>
+export type OnDrawForegroundParams = Parameters<LGraphNode['onDrawForeground']>
+export type OnMouseDownParams = Parameters<LGraphNode['onMouseDown']>
+export type OnConnectionsChangeParams = Parameters<
+  LGraphNode['onConnectionsChange']
+>
+export type OnNodeCreatedParams = Parameters<
+  LGraphNodeExtension['onNodeCreated']
+>
+
+export interface DocumentationOptions {
+  icon_size?: number
+  icon_margin?: number
+}
@@ -0,0 +1,18 @@
+/**
+ * @typedef {import("./shared.d.ts").NodeData} NodeData
+ * @typedef {import("./shared.d.ts").NodeType} NodeType
+ * @typedef {import("./shared.d.ts").DocumentationOptions} DocumentationOptions
+ * @typedef {import("./shared.d.ts").OnDrawForegroundParams} OnDrawForegroundParams
+ * @typedef {import("./shared.d.ts").OnMouseDownParams} OnMouseDownParams
+ * @typedef {import("./shared.d.ts").OnConnectionsChangeParams} OnConnectionsChangeParams
+ * @typedef {import("./shared.d.ts").ContextMenuItem} ContextMenuItem
+ * @typedef {import("./shared.d.ts").IWidget} IWidget
+ * @typedef {import("./shared.d.ts").VectorWidget} VectorWidget
+ * @typedef {import("./shared.d.ts").LGraphNodeExtended} LGraphNode
+ * @typedef {import("./shared.d.ts").LLink} LLink
+ * @typedef {import("./shared.d.ts").App} App
+ * @typedef {import("./shared.d.ts").OnDrawWidgetParams} OnDrawWidgetParams
+ * @typedef {import("./shared.d.ts").INodeInputSlot} INodeInputSlot
+ * @typedef {import("./shared.d.ts").INodeOutputSlot} INodeOutputSlot
+ */
+
@@ -1,5 +1,6 @@
 import contextlib
 import functools
+import importlib
 import math
 import os
 import shlex
@@ -8,11 +9,14 @@ import socket
 import subprocess
 import sys
 import uuid
+from collections.abc import Callable, Sequence
+from enum import Enum
 from pathlib import Path
-from typing import List, Optional, Union
+from typing import TypeVar

 import folder_paths
 import numpy as np
+import numpy.typing as npt
 import requests
 import torch
 from PIL import Image
@@ -43,6 +47,117 @@ def make_report():
 # endregion


+# region NFOV
+class numpy_NFOV:
+    def __init__(self, fov=None, height: int = 400, width: int = 800):
+        self.field_of_view = fov or [0.45, 0.45]
+        self.PI = np.pi
+        self.PI_2 = np.pi * 0.5
+        self.PI2 = np.pi * 2.0
+        self.height = height
+        self.width = width
+        self.screen_points = self._get_screen_img()
+
+    def _get_coord_rad(self, is_center_point, center_point=None):
+        if is_center_point:
+            center_point = np.array(center_point)
+            return (center_point * 2 - 1) * np.array([self.PI, self.PI_2])
+        else:
+            return (
+                (self.screen_points * 2 - 1)
+                * np.array([self.PI, self.PI_2])
+                * (np.ones(self.screen_points.shape) * self.field_of_view)
+            )
+
+    def _get_screen_img(self):
+        xx, yy = np.meshgrid(
+            np.linspace(0, 1, self.width), np.linspace(0, 1, self.height)
+        )
+        return np.array([xx.ravel(), yy.ravel()]).T
+
+    def _calc_spherical_to_gnomonic(self, converted_screen_coord):
+        x = converted_screen_coord.T[0]
+        y = converted_screen_coord.T[1]
+
+        rou = np.sqrt(x**2 + y**2)
+        c = np.arctan(rou)
+        sin_c = np.sin(c)
+        cos_c = np.cos(c)
+
+        lat = np.arcsin(
+            cos_c * np.sin(self.cp[1]) + (y * sin_c * np.cos(self.cp[1])) / rou
+        )
+        lon = self.cp[0] + np.arctan2(
+            x * sin_c,
+            rou * np.cos(self.cp[1]) * cos_c - y * np.sin(self.cp[1]) * sin_c,
+        )
+
+        lat = (lat / self.PI_2 + 1.0) * 0.5
+        lon = (lon / self.PI + 1.0) * 0.5
+
+        return np.array([lon, lat]).T
+
+    def _bilinear_interpolation(self, screen_coord):
+        uf = np.mod(screen_coord.T[0], 1) * self.frame_width  # long - width
+        vf = np.mod(screen_coord.T[1], 1) * self.frame_height  # lat - height
+
+        x0 = np.floor(uf).astype(int)  # coord of pixel to bottom left
+        y0 = np.floor(vf).astype(int)
+        x2 = np.add(
+            x0, np.ones(uf.shape).astype(int)
+        )  # coords of pixel to top right
+        y2 = np.add(y0, np.ones(vf.shape).astype(int))
+
+        base_y0 = np.multiply(y0, self.frame_width)
+        base_y2 = np.multiply(y2, self.frame_width)
+
+        A_idx = np.add(base_y0, x0)
+        B_idx = np.add(base_y2, x0)
+        C_idx = np.add(base_y0, x2)
+        D_idx = np.add(base_y2, x2)
+
+        flat_img = np.reshape(self.frame, [-1, self.frame_channel])
+
+        A = np.take(flat_img, A_idx, axis=0)
+        B = np.take(flat_img, B_idx, axis=0)
+        C = np.take(flat_img, C_idx, axis=0)
+        D = np.take(flat_img, D_idx, axis=0)
+
+        wa = np.multiply(x2 - uf, y2 - vf)
+        wb = np.multiply(x2 - uf, vf - y0)
+        wc = np.multiply(uf - x0, y2 - vf)
+        wd = np.multiply(uf - x0, vf - y0)
+
+        # interpolate
+        AA = np.multiply(A, np.array([wa, wa, wa]).T)
+        BB = np.multiply(B, np.array([wb, wb, wb]).T)
+        CC = np.multiply(C, np.array([wc, wc, wc]).T)
+        DD = np.multiply(D, np.array([wd, wd, wd]).T)
+        nfov = np.reshape(
+            np.round(AA + BB + CC + DD).astype(np.uint8),
+            [self.height, self.width, 3],
+        )
+
+        return nfov
+
+    def to_nfov(self, frame, center_point):
+        self.frame = frame
+        self.frame_height = frame.shape[0]
+        self.frame_width = frame.shape[1]
+        self.frame_channel = frame.shape[2]
+
+        self.cp = self._get_coord_rad(
+            center_point=center_point, is_center_point=True
+        )
+        converted_screen_coord = self._get_coord_rad(is_center_point=False)
+        return self._bilinear_interpolation(
+            self._calc_spherical_to_gnomonic(converted_screen_coord)
+        )
+
+
+# endregion
+
+
 # region SERVER Utilities
 class IPChecker:
    def __init__(self):
@@ -97,12 +212,120 @@ def get_server_info():


 # region MISC Utilities
+
+
+# TODO: use mtb.core directly instead of copying parts here
+T = TypeVar("T", bound="StringConvertibleEnum")
+
+
+class StringConvertibleEnum(Enum):
+    """Base class for enums with utility methods for string conversion and member listing."""
+
+    @classmethod
+    def from_str(cls: type[T], label: str | T) -> T:
+        """
+        Convert a string to the corresponding enum value (case sensitive).
+
+        Args:
+            label (Union[str, T]): The string or enum value to convert.
+
+        Returns
+        -------
+            T: The corresponding enum value.
+
+        Raises
+        ------
+            ValueError: If the label does not correspond to any enum member.
+        """
+        if isinstance(label, cls):
+            return label
+        if isinstance(label, str):
+            # from key
+            if label in cls.__members__:
+                return cls[label]
+
+            for member in cls:
+                if member.value == label:
+                    return member
+
+        raise ValueError(
+            f"Unknown label: '{label}'. Valid members: {list(cls.__members__.keys())}, "
+            f"valid values: {cls.list_members()}"
+        )
+
+    @classmethod
+    def to_str(cls: type[T], enum_value: T) -> str:
+        """
+        Convert an enum value to its string representation.
+
+        Args:
+            enum_value (T): The enum value to convert.
+
+        Returns
+        -------
+            str: The string representation of the enum value.
+
+        Raises
+        ------
+            ValueError: If the enum value is invalid.
+        """
+        if isinstance(enum_value, cls):
+            return enum_value.value
+        raise ValueError(f"Invalid Enum: {enum_value}")
+
+    @classmethod
+    def list_members(cls: type[T]) -> list[str]:
+        """
+        Return a list of string representations of all enum members.
+
+        Returns
+        -------
+            List[str]: List of all enum member values.
+        """
+        return [enum.value for enum in cls]
+
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the enum value.
+
+        Returns
+        -------
+            str: The string representation of the enum value.
+        """
+        return self.value
+
+
+class Precision(StringConvertibleEnum):
+    FULL = "full"
+    FP32 = "fp32"
+    FP16 = "fp16"
+    BF16 = "bf16"
+    FP8 = "fp8"
+
+    def to_dtype(self):
+        match self:
+            case Precision.FP32 | Precision.FULL:
+                return torch.float32
+            case Precision.FP16:
+                return torch.float16
+            case Precision.BF16:
+                return torch.bfloat16
+            case Precision.FP8:
+                return torch.float8_e4m3fn
+
+
+class Operation(StringConvertibleEnum):
+    COPY = "copy"
+    CONVERT = "convert"
+    DELETE = "delete"
+
+
 def backup_file(
    fp: Path,
-    target: Optional[Path] = None,
+    target: Path | None = None,
    backup_dir: str = ".bak",
-    suffix: Optional[str] = None,
-    prefix: Optional[str] = None,
+    suffix: str | None = None,
+    prefix: str | None = None,
 ):
    if not fp.exists():
        raise FileNotFoundError(f"No file found at {fp}")
@@ -204,12 +427,6 @@ def _run_command(shell_cmd, ignored_lines_start):
    print("Command executed successfully!")


-# todo use the requirements library
-reqs_map = {value: key for key, value in pip_map.items()}
-
-import importlib
-
-
 def import_install(package_name):
    package_spec = reqs_map.get(package_name, package_name)

@@ -249,6 +466,7 @@ here = Path(__file__).parent.absolute()
 comfy_dir = Path(folder_paths.base_path)
 models_dir = Path(folder_paths.models_dir)
 output_dir = Path(folder_paths.output_directory)
+input_dir = Path(folder_paths.input_directory)
 styles_dir = comfy_dir / "styles"
 session_id = str(uuid.uuid4())
 # - Construct the path to the font file
@@ -257,6 +475,7 @@ font_path = here / "data" / "font.ttf"
 # - Add extern folder to path
 extern_root = here / "extern"
 add_path(extern_root)
+
 for pth in extern_root.iterdir():
    if pth.is_dir():
        add_path(pth)
@@ -265,6 +484,14 @@ for pth in extern_root.iterdir():
 add_path(comfy_dir)
 add_path(comfy_dir / "custom_nodes")

+
+# TODO: use the requirements library
+reqs_map = {value: key for key, value in pip_map.items()}
+
+# NOTE: store already logged warnings to only alert once.
+warned_messages: set[str] = set()
+
+
 PIL_FILTER_MAP = {
    "nearest": Image.Resampling.NEAREST,
    "box": Image.Resampling.BOX,
@@ -277,52 +504,92 @@ PIL_FILTER_MAP = {


 # region TENSOR Utilities
-def tensor2pil(image: torch.Tensor) -> List[Image.Image]:
-    batch_count = image.size(0) if len(image.shape) > 3 else 1
-    if batch_count > 1:
-        out = []
-        for i in range(batch_count):
-            out.extend(tensor2pil(image[i]))
-        return out
-
-    return [
-        Image.fromarray(
-            np.clip(255.0 * image.cpu().numpy().squeeze(), 0, 255).astype(
-                np.uint8
-            )
-        )
-    ]
+def to_numpy(image: torch.Tensor) -> npt.NDArray[np.uint8]:
+    """Converts a tensor to a ndarray with proper scaling and type conversion."""
+    log.debug(f"Converting tensor to numpy array with shape {image.shape}")
+    np_array = np.clip(255.0 * image.cpu().numpy(), 0, 255).astype(np.uint8)
+    log.debug(f"Numpy array shape after conversion: {np_array.shape}")
+    return np_array


-def pil2tensor(image: Union[Image.Image, List[Image.Image]]) -> torch.Tensor:
-    if isinstance(image, list):
-        return torch.cat([pil2tensor(img) for img in image], dim=0)
-
-    return torch.from_numpy(
-        np.array(image).astype(np.float32) / 255.0
-    ).unsqueeze(0)
+def handle_batch(
+    tensor: torch.Tensor,
+    func: Callable[[torch.Tensor], Image.Image | npt.NDArray[np.uint8]],
+) -> list[Image.Image] | list[npt.NDArray[np.uint8]]:
+    """Handles batch processing for a given tensor and conversion function."""
+    return [func(tensor[i]) for i in range(tensor.shape[0])]


-def np2tensor(img_np: Union[np.ndarray, List[np.ndarray]]) -> torch.Tensor:
-    if isinstance(img_np, list):
-        return torch.cat([np2tensor(img) for img in img_np], dim=0)
+def tensor2pil(tensor: torch.Tensor) -> list[Image.Image]:
+    """Converts a batch of tensors to a list of PIL Images."""

-    return torch.from_numpy(img_np.astype(np.float32) / 255.0).unsqueeze(0)
+    def single_tensor2pil(t: torch.Tensor) -> Image.Image:
+        np_array = to_numpy(t)
+        if np_array.ndim == 2:  # (H, W) for masks
+            return Image.fromarray(np_array, mode="L")
+        elif np_array.ndim == 3:  # (H, W, C) for RGB/RGBA
+            if np_array.shape[2] == 3:
+                return Image.fromarray(np_array, mode="RGB")
+            elif np_array.shape[2] == 4:
+                return Image.fromarray(np_array, mode="RGBA")
+        raise ValueError(f"Invalid tensor shape: {t.shape}")
+
+    return handle_batch(tensor, single_tensor2pil)


-def tensor2np(tensor: torch.Tensor) -> List[np.ndarray]:
-    batch_count = tensor.size(0) if len(tensor.shape) > 3 else 1
-    if batch_count > 1:
-        out = []
-        for i in range(batch_count):
-            out.extend(tensor2np(tensor[i]))
-        return out
+def pil2tensor(images: Image.Image | list[Image.Image]) -> torch.Tensor:
+    """Converts a PIL Image or a list of PIL Images to a tensor."""

-    return [
-        np.clip(255.0 * tensor.cpu().numpy().squeeze(), 0, 255).astype(
-            np.uint8
-        )
-    ]
+    def single_pil2tensor(image: Image.Image) -> torch.Tensor:
+        np_image = np.array(image).astype(np.float32) / 255.0
+        if np_image.ndim == 2:  # Grayscale
+            return torch.from_numpy(np_image).unsqueeze(0)  # (1, H, W)
+        else:  # RGB or RGBA
+            return torch.from_numpy(np_image).unsqueeze(0)  # (1, H, W, C)
+
+    if isinstance(images, Image.Image):
+        return single_pil2tensor(images)
+    else:
+        return torch.cat([single_pil2tensor(img) for img in images], dim=0)
+
+
+def np2tensor(
+    np_array: npt.NDArray[np.float32] | Sequence[npt.NDArray[np.float32]],
+) -> torch.Tensor:
+    """Converts a NumPy array or a list of NumPy arrays to a tensor."""
+
+    def single_np2tensor(array: npt.NDArray[np.float32]) -> torch.Tensor:
+        if array.ndim == 2:  # (H, W) for masks
+            return torch.from_numpy(
+                array.astype(np.float32) / 255.0
+            ).unsqueeze(0)  # (1, H, W)
+        elif array.ndim == 3:  # (H, W, C) for RGB/RGBA
+            return torch.from_numpy(
+                array.astype(np.float32) / 255.0
+            ).unsqueeze(0)  # (1, H, W, C)
+        raise ValueError(f"Invalid array shape: {array.shape}")
+
+    if isinstance(np_array, np.ndarray):
+        return single_np2tensor(np_array)
+    else:
+        return torch.cat([single_np2tensor(arr) for arr in np_array], dim=0)
+
+
+def tensor2np(tensor: torch.Tensor) -> list[npt.NDArray[np.uint8]]:
+    """Converts a batch of tensors to a list of NumPy arrays."""
+
+    def single_tensor2np(t: torch.Tensor) -> npt.NDArray[np.uint8]:
+        t = t.squeeze()  # Remove any singleton dimensions
+        if t.ndim == 2:  # (H, W) for masks
+            return to_numpy(t)
+        elif t.ndim == 3:  # (C, H, W) for RGB/RGBA
+            if t.shape[0] in [1, 3, 4]:  # Channel-first format
+                t = t.permute(1, 2, 0)
+            return to_numpy(t)
+        else:
+            raise ValueError(f"Invalid tensor shape: {t.shape}")
+
+    return handle_batch(tensor, single_tensor2np)


 def pad(img, left, right, top, bottom):
@@ -572,10 +839,11 @@ def get_model_path(fam, model=None):
    if res:
        if isinstance(res, list):
            if len(res) > 1:
-                log.warning(
-                    f"Found multiple match, we will pick the first {res[0]}\n{res}"
-                )
-            res = res[0]
+                warn_msg = f"Found multiple match, we will pick the last {res[-1]}\n{res}"
+                if warn_msg not in warned_messages:
+                    log.info(warn_msg)
+                    warned_messages.add(warn_msg)
+            res = res[-1]
        res = Path(res)
        log.debug(f"Resolved model path from folder_paths: {res}")
    else:
@@ -609,6 +877,32 @@ def create_uv_map_tensor(width=512, height=512):


 # region ANIMATION Utilities
+EASINGS = [
+    "Linear",
+    "Sine In",
+    "Sine Out",
+    "Sine In/Out",
+    "Quart In",
+    "Quart Out",
+    "Quart In/Out",
+    "Cubic In",
+    "Cubic Out",
+    "Cubic In/Out",
+    "Circ In",
+    "Circ Out",
+    "Circ In/Out",
+    "Back In",
+    "Back Out",
+    "Back In/Out",
+    "Elastic In",
+    "Elastic Out",
+    "Elastic In/Out",
+    "Bounce In",
+    "Bounce Out",
+    "Bounce In/Out",
+]
+
+
 def apply_easing(value, easing_type):
    if easing_type == "Linear":
        return value
@@ -0,0 +1,496 @@
+import { app } from '../../scripts/app.js'
+import * as shared from './comfy_shared.js'
+import { infoLogger } from './comfy_shared.js'
+import { MtbWidgets } from './mtb_widgets.js'
+import { ComfyWidgets } from '../../scripts/widgets.js'
+import * as mtb_widgets from './mtb_widgets.js'
+
+/**
+ * @typedef {'number'|'string'|'vector2'|'vector3'|'vector4'|'color'} ConstantType
+ * @typedef {import ("../../../web/types/litegraph.d.ts").LGraphNode} Node
+ * @typedef {{x:number,y:number,z?:number,w?:number}} VectorValue
+ * @typedef {}
+ *
+ */
+
+/**
+ * @param {number} size - The number of axis of the vector (2,3 or 4)
+ * @param {number} val - The default scalar value to fill the vector with
+ * @returns {VectorValue} vector
+ * */
+const initVector = (size, val = 0.0) => {
+  const res = {}
+  for (let i = 0; i < size; i++) {
+    const axis = mtb_widgets.VECTOR_AXIS[i]
+    res[axis] = val
+  }
+  return res
+}
+
+/**
+ *
+ * @extends {Node}
+ * @classdesc Wrapper for the python node
+ */
+export class ConstantJs {
+  constructor(python_node) {
+    // this.uuid = shared.makeUUID()
+    const wrapper = this
+
+    python_node.shape = LiteGraph.BOX_SHAPE
+    python_node.serialize_widgets = true
+
+    const onNodeCreated = python_node.prototype.onNodeCreated
+    python_node.prototype.onNodeCreated = function () {
+      const r = onNodeCreated ? onNodeCreated.apply(this) : undefined
+
+      this.addProperty('type', 'number')
+      this.addProperty('value', 0)
+
+      this.removeInput(0)
+      this.removeOutput(0)
+
+      this.addOutput('Output', '*')
+
+      // bind our wrapper
+      this.configure = wrapper.configure.bind(this)
+      // this.applyToGraph = wrapper.applyToGraph.bind(this)
+      this.updateWidgets = wrapper.updateWidgets.bind(this)
+      this.convertValue = wrapper.convertValue.bind(this)
+      // this.updateOutput = wrapper.updateOutput.bind(this)
+      this.updateOutputType = wrapper.updateOutputType.bind(this)
+      // this.updateTargetWidgets = wrapper.updateTargetWidgets.bind(this)
+
+      this.addWidget(
+        'combo',
+        'Type',
+        this.properties.type,
+        (value) => {
+          this.properties.type = value
+          this.updateWidgets()
+          this.updateOutputType()
+        },
+        {
+          values: [
+            // 'number',
+            'float',
+            'int',
+            'string',
+            'vector2',
+            'vector3',
+            'vector4',
+            'color',
+          ],
+        },
+      )
+      this.updateWidgets()
+      this.updateOutputType()
+
+      for (let n = 0; n < this.inputs.length; n++) {
+        this.removeInput(n)
+      }
+      this.inputs = []
+      return r
+    }
+    return
+  }
+
+  // NOTE: this is called onPrompt
+  // applyToGraph() {
+  // infoLogger('Updating values for backend')
+  // this.updateTargetWidgets()
+  // }
+
+  // NOTE: deserialization happens here
+  configure(info) {
+    // super.configure(info)
+    infoLogger('Configure Constant', { info, node: this })
+
+    this.properties.type = info.properties.type
+    this.properties.value = info.properties.value
+
+    this.pos = info.pos
+    this.order = info.order
+
+    this.updateWidgets()
+    this.updateOutputType()
+  }
+
+  /**
+   * Convert the old value type to the new one, falling back to some default
+   * @param {ConstantType} propType - The target type
+   */
+  convertValue(propType) {
+    switch (propType) {
+      case 'color': {
+        if (typeof this.properties.value !== 'string') {
+          this.properties.value = '#ffffff'
+        } else if (this.properties.value[0] !== '#') {
+          this.properties.value = '#ff0000'
+        }
+        break
+      }
+      case 'int': {
+        if (typeof this.properties.value === 'object') {
+          this.properties.value = Number.parseInt(this.properties.value.x)
+        } else {
+          this.properties.value = Number.parseInt(this.properties.value) || 0
+        }
+        break
+      }
+      case 'float': {
+        if (typeof this.properties.value === 'object') {
+          this.properties.value = Number.parseFloat(this.properties.value.x)
+        } else {
+          this.properties.value =
+            Number.parseFloat(this.properties.value) || 0.0
+        }
+        break
+      }
+      case 'string': {
+        if (typeof this.properties.value !== 'string') {
+          this.properties.value = JSON.stringify(this.properties.value)
+        }
+        break
+      }
+      case 'vector2':
+      case 'vector3':
+      case 'vector4': {
+        const numInputs = Number.parseInt(propType.charAt(6))
+        if (!this.properties.value) {
+          this.properties.value = initVector(numInputs) // Array.from({ length: numInputs }, () => 0.0)
+        } else if (typeof this.properties.value === 'string') {
+          try {
+            const parsed = JSON.parse(this.properties.value)
+            const newVec = {}
+            for (
+              let i = 0;
+              i < Object.keys(mtb_widgets.VECTOR_AXIS).length;
+              i++
+            ) {
+              const axis = mtb_widgets.VECTOR_AXIS[i]
+              if (Object.keys(parsed).includes(axis)) {
+                newVec[axis] = parsed[axis]
+              }
+            }
+            this.properties.value = newVec
+          } catch (e) {
+            shared.errorLogger(e)
+            infoLogger(
+              `Couldn't parse string to vec (${this.properties.value})`,
+            )
+            this.properties.value = initVector(numInputs)
+          }
+        } else if (typeof this.properties.value === 'number') {
+          const newVec = initVector(numInputs)
+          newVec.x = Number.parseFloat(this.properties.value)
+          this.properties.value = newVec
+        }
+
+        if (
+          typeof this.properties.value === 'object' &&
+          Object.keys(this.properties.value).length !== numInputs
+        ) {
+          const current = Object.keys(this.properties.value)
+          if (current.length < numInputs) {
+            infoLogger('current value smaller than target, adjusting')
+            for (let index = current.length; index < numInputs; index++) {
+              this.properties.value[mtb_widgets.VECTOR_AXIS[index]] = 0.0
+            }
+          } else {
+            infoLogger('current value greater than target, adjusting')
+            const newVal = {}
+            for (let index = 0; index < numInputs; index++) {
+              newVal[mtb_widgets.VECTOR_AXIS[index]] =
+                this.properties.value[mtb_widgets.VECTOR_AXIS[index]]
+            }
+            this.properties.value = newVal
+          }
+        }
+        break
+      }
+      default:
+        break
+    }
+  }
+
+  /**
+   * Remove all widgets but the comboBox for selecting the type
+   * then recreate the appropriate widget from scratch
+   */
+  updateWidgets() {
+    // NOTE: Remove existing widgets
+    for (let i = 1; i < this.widgets.length; i++) {
+      const element = this.widgets[i]
+      if (element.onRemove) {
+        element.onRemove()
+      }
+      // element?.onRemove()
+    }
+
+    this.widgets.splice(1)
+    this.widgets[0].value = this.properties.type
+
+    this.convertValue(this.properties.type)
+
+    switch (this.properties.type) {
+      case 'color': {
+        const col_widget = this.addCustomWidget(
+          MtbWidgets.COLOR('Value', this.properties.value),
+        )
+        col_widget.callback = (col) => {
+          this.properties.value = col
+          // this.updateOutput()
+        }
+        break
+      }
+      case 'int': {
+        const f_widget = this.addCustomWidget(
+          ComfyWidgets.INT(
+            this,
+            'Value',
+            [
+              '',
+              {
+                default: this.properties.value,
+                callback: (val) => console.log('VALUE', val),
+              },
+            ],
+            app,
+          ),
+        )
+
+        f_widget.widget.callback = (val) => {
+          this.properties.value = val
+        }
+
+        break
+      }
+      case 'float': {
+        this.addWidget('number', 'Value', this.properties.value, (val) => {
+          this.properties.value = val
+        })
+        break
+      }
+      case 'string': {
+        mtb_widgets.addMultilineWidget(
+          this,
+          'Value',
+          {
+            defaultVal: this.properties.value,
+          },
+          (v) => {
+            this.properties.value = v
+            // this.updateOutput()
+          },
+        )
+        break
+      }
+      case 'vector2':
+      case 'vector3':
+      case 'vector4': {
+        const numInputs = Number.parseInt(this.properties.type.charAt(6))
+        const node = this
+        const v_widget = mtb_widgets.addVectorWidget(
+          this,
+          'Value',
+          this.properties.value, // value
+          numInputs, // vector_size
+          function (v) {
+            node.properties.value = v
+            // this.updateOutput()
+          },
+        )
+        break
+      }
+
+      // NOTE: this is not reached anymore, kept for reference
+      case 'number': {
+        if (typeof this.properties.value !== 'number') {
+          this.properties.value = 0.0
+        }
+        const n_widget = this.addWidget(
+          'number',
+          'Value',
+          this.properties.force_int
+            ? Number.parseInt(this.properties.value)
+            : this.properties.value,
+          (value) => {
+            this.properties.value = this.properties.force_int
+              ? Number.parseInt(value)
+              : value
+            // this.updateOutput()
+          },
+        )
+        //override the callback
+        const origCallback = n_widget.callback
+        const node = this
+        n_widget.callback = function (val) {
+          const r = origCallback ? origCallback.apply(this, [val]) : undefined
+          if (node.properties.force_int) {
+            // TODO: rework this, a it makes it harder to manipulate
+            this.value = Number.parseInt(this.value)
+            node.properties.value = Number.parseInt(this.value)
+          }
+          infoLogger('NEW NUMBER', this.value)
+          return r
+        }
+
+        this.addWidget(
+          'toggle',
+          'Convert to Integer',
+          this.properties.force_int,
+          (value) => {
+            this.properties.force_int = value
+            this.updateOutputType()
+          },
+        )
+        break
+      }
+      default:
+        break
+    }
+  }
+  onConnectionsChange(type, slotIndex, isConnected, link, ioSlot) {
+    // super.onConnectionsChange(type, slotIndex, isConnected, link, ioSlot)
+    if (isConnected) {
+      this.updateTargetWidgets([link.id])
+    }
+  }
+
+  updateOutputType() {
+    infoLogger('Updating output type')
+    const rm_if_mismatch = (type) => {
+      if (this.outputs[0].type !== type) {
+        for (let i = 0; i < this.outputs.length; i++) {
+          this.removeOutput(i)
+        }
+        this.addOutput('output', type)
+        // this.setOutputDataType(0, type)
+      }
+    }
+    switch (this.properties.type) {
+      case 'color':
+        rm_if_mismatch('COLOR')
+        break
+      case 'float':
+        rm_if_mismatch('FLOAT')
+        break
+      case 'int':
+        rm_if_mismatch('INT')
+        break
+      case 'number':
+        if (this.properties.force_int) {
+          rm_if_mismatch('INT')
+        } else {
+          rm_if_mismatch('FLOAT')
+        }
+        break
+      case 'string':
+        rm_if_mismatch('STRING')
+        break
+      // case 'vector2':
+      // case 'vector3':
+      // case 'vector4':
+      //   rm_if_mismatch('FLOAT')
+      //   break
+      case 'vector2':
+        rm_if_mismatch('VECTOR2')
+        break
+      case 'vector3':
+        rm_if_mismatch('VECTOR3')
+        break
+      case 'vector4':
+        rm_if_mismatch('VECTOR4')
+        break
+      default:
+        break
+    }
+    // this.updateOutput()
+  }
+
+  /**
+   * NOTE: This feels hacky but seems to work fine
+   * since Constant is a virtual node.
+   */
+  updateTargetWidgets(u_links) {
+    infoLogger('Updating target widgets')
+    if (!app.graph.links) return
+    const links = u_links || this.outputs[0].links
+    if (!links) return
+    for (let i = 0; i < links.length; i++) {
+      const link = app.graph.links[links[i]]
+      const tgt_node = app.graph.getNodeById(link.target_id)
+      if (!tgt_node || !tgt_node.inputs) return
+      const tgt_input = tgt_node.inputs[link.target_slot]
+      if (!tgt_input) return
+      const tgt_widget = tgt_node.widgets.filter(
+        (w) => w.name === tgt_input.name,
+      )
+      // infoLogger('Constant Target Node', tgt_node)
+      // infoLogger('Constant Target Input', tgt_input)
+      if (!tgt_widget || tgt_widget.length === 0) return
+
+      tgt_widget[0].value = this.properties.value
+    }
+  }
+
+  updateOutput() {
+    infoLogger('Updating output value')
+    const value = this.properties.value
+
+    switch (this.properties.type) {
+      case 'color':
+        this.setOutputData(0, value)
+        break
+      case 'number':
+        if (this.properties.force_int) {
+          this.setOutputData(0, Number.parseInt(value))
+        } else {
+          this.setOutputData(0, Number.parseFloat(value))
+        }
+        break
+      case 'string':
+        this.setOutputData(0, value.toString())
+        break
+      case 'vector2':
+      case 'vector3':
+      case 'vector4':
+        this.setOutputData(0, value)
+        break
+
+      // case 'vector2':
+      //   this.setOutputData(0, value.slice(0, 2))
+      //   break
+      // case 'vector3':
+      //   this.setOutputData(0, value.slice(0, 3))
+      //   break
+      // case 'vector4':
+      //   this.setOutputData(0, value.slice(0, 4))
+      //   break
+      default:
+        break
+    }
+
+    infoLogger('New Value', this.value)
+
+    this.updateTargetWidgets()
+  }
+}
+app.registerExtension({
+  name: 'mtb.constant',
+
+  async beforeRegisterNodeDef(nodeType, nodeData, _app) {
+    if (nodeData.name === 'Constant (mtb)') {
+      new ConstantJs(nodeType)
+    }
+  },
+  // NOTE: old js only registration
+  //
+  // registerCustomNodes() {
+  //   LiteGraph.registerNodeType('Constant (mtb)', Constant)
+  //
+  //   Constant.category = 'mtb/utils'
+  //   Constant.title = 'Constant (mtb)'
+  // },
+})
@@ -1,187 +1,221 @@
-
+// Reference the shared typedefs file
+/// <reference path="../types/typedefs.js" />
 import { app } from '../../scripts/app.js'
+import { infoLogger } from './comfy_shared.js'

-function B0(t) { return (1 - t) ** 3 / 6; }
-function B1(t) { return (3 * t ** 3 - 6 * t ** 2 + 4) / 6; }
-function B2(t) { return (-3 * t ** 3 + 3 * t ** 2 + 3 * t + 1) / 6; }
-function B3(t) { return t ** 3 / 6; }
-
+function B0(t) {
+  return (1 - t) ** 3 / 6
+}
+function B1(t) {
+  return (3 * t ** 3 - 6 * t ** 2 + 4) / 6
+}
+function B2(t) {
+  return (-3 * t ** 3 + 3 * t ** 2 + 3 * t + 1) / 6
+}
+function B3(t) {
+  return t ** 3 / 6
+}
 class CurveWidget {
-    constructor(inputName, defaultValue) {
-        this.name = inputName || "Curve";
-        this._value = defaultValue || [{ x: 0, y: 0 }, { x: 1, y: 1 }];
-        this.type = "FLOAT_CURVE";
-        this.selectedPointIndex = null;
-        this.resize
-    }
+  constructor(...args) {
+    const [inputName, opts] = args

-    drawBSpline(ctx, width, height, posY) {
-        const n = this._value.length - 1;
-        const numSegments = n - 2;
-        const numPoints = this._value.length;
-        if (numPoints < 4) {
-            this.drawLinear(ctx, width, height, posY);
-        } else {
-            for (let j = 0; j <= numSegments; j++) {
-                for (let t = 0; t <= 1; t += 0.01) {
-                    let pt = this.getBSplinePoint(j, t);
-                    let x = pt.x * width;
-                    let y = posY + height - pt.y * height;
+    this.name = inputName || 'Curve'

-                    if (t === 0) ctx.moveTo(x, y);
-                    else ctx.lineTo(x, y);
-                }
-            }
-            ctx.stroke();
+    this.type = 'FLOAT_CURVE'
+    this.selectedPointIndex = null
+    this.options = opts
+    this.value = this.value || { 0: { x: 0, y: 0 }, 1: { x: 1, y: 1 } }
+  }
+
+  drawBSpline(ctx, width, height, posY) {
+    const n = this.value.length - 1
+    const numSegments = n - 2
+    const numPoints = this.value.length
+    if (numPoints < 4) {
+      this.drawLinear(ctx, width, height, posY)
+    } else {
+      for (let j = 0; j <= numSegments; j++) {
+        for (let t = 0; t <= 1; t += 0.01) {
+          let pt = this.getBSplinePoint(j, t)
+          let x = pt.x * width
+          let y = posY + height - pt.y * height
+
+          if (t === 0) ctx.moveTo(x, y)
+          else ctx.lineTo(x, y)
        }
+      }
+      ctx.stroke()
+    }
+  }
+
+  drawLinear(ctx, width, height, posY) {
+    for (let i = 0; i < Object.keys(this.value).length - 1; i++) {
+      let p1 = this.value[i]
+      let p2 = this.value[i + 1]
+      ctx.moveTo(p1.x * width, posY + height - p1.y * height)
+      ctx.lineTo(p2.x * width, posY + height - p2.y * height)
+    }
+    ctx.stroke()
+  }
+  getBSplinePoint(i, t) {
+    // Control points for this segment
+    const p0 = this.value[i]
+    const p1 = this.value[i + 1]
+    const p2 = this.value[i + 2]
+    const p3 = this.value[i + 3]
+
+    const x = B0(t) * p0.x + B1(t) * p1.x + B2(t) * p2.x + B3(t) * p3.x
+    const y = B0(t) * p0.y + B1(t) * p1.y + B2(t) * p2.y + B3(t) * p3.y
+
+    return { x, y }
+  }
+  /**
+   * @param {OnDrawWidgetParams} args
+   */
+  draw(...args) {
+    const hide = this.type !== 'FLOAT_CURVE'
+    if (hide) {
+      return
    }

-    drawLinear(ctx, width, height, posY) {
-        for (let i = 0; i < this._value.length - 1; i++) {
-            let p1 = this._value[i];
-            let p2 = this._value[i + 1];
-            ctx.moveTo(p1.x * width, posY + height - p1.y * height);
-            ctx.lineTo(p2.x * width, posY + height - p2.y * height);
-        }
-        ctx.stroke();
+    const [ctx, node, width, posY, height] = args
+    const [cw, ch] = this.computeSize(width)
+
+    ctx.beginPath()
+    ctx.fillStyle = '#000'
+    ctx.strokeStyle = '#fff'
+    ctx.lineWidth = 2
+
+    // normalized coordinates -> canvas coordinates
+    for (let i = 0; i < Object.keys(this.value || {}).length - 1; i++) {
+      let p1 = this.value[i]
+      let p2 = this.value[i + 1]
+      ctx.moveTo(p1.x * cw, posY + ch - p1.y * ch)
+      ctx.lineTo(p2.x * cw, posY + ch - p2.y * ch)
+    }
+    ctx.stroke()
+
+    // points
+    Object.values(this.value || {}).forEach((point) => {
+      ctx.beginPath()
+      ctx.arc(point.x * cw, posY + ch - point.y * ch, 5, 0, 2 * Math.PI)
+      ctx.fill()
+    })
+  }
+
+  mouse(event, pos, node) {
+    let x = pos[0] - node.pos[0]
+    let y = pos[1] - node.pos[1]
+    const width = node.size[0]
+    const height = 300 // TODO: compute
+    const posY = node.pos[1]
+    const localPos = { x: pos[0], y: pos[1] - LiteGraph.NODE_WIDGET_HEIGHT }
+
+    if (event.type === LiteGraph.pointerevents_method + 'down') {
+      console.debug('Checking if a point was clicked')
+      const clickedPointIndex = this.detectPoint(localPos, width, height)
+      if (clickedPointIndex !== null) {
+        this.selectedPointIndex = clickedPointIndex
+      } else {
+        this.addPoint(localPos, width, height)
+      }
+      return true
+    } else if (
+      event.type === LiteGraph.pointerevents_method + 'move' &&
+      this.selectedPointIndex !== null
+    ) {
+      this.movePoint(this.selectedPointIndex, localPos, width, height)
+      return true
+    } else if (
+      event.type === LiteGraph.pointerevents_method + 'up' &&
+      this.selectedPointIndex !== null
+    ) {
+      this.selectedPointIndex = null
+      return true
+    }
+    return false
+  }
+  callback(...args) {
+    //value, that, node, pos, event) {
+
+  }
+
+  detectPoint(localPos, width, height) {
+    const threshold = 20 // TODO: extract
+    const keys = Object.keys(this.value)
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      const p = this.value[key]
+      const px = p.x * width
+      const py = height - p.y * height
+      if (
+        Math.abs(localPos.x - px) < threshold &&
+        Math.abs(localPos.y - py) < threshold
+      ) {
+        return key
+      }
+    }
+    return null
+  }
+  addPoint(localPos, width, height) {
+    // add a new point based on click position
+    const normalizedPoint = {
+      x: localPos.x / width,
+      y: 1 - localPos.y / height,
    }

-    getBSplinePoint(i, t) {
-        // Control points for this segment
-        const p0 = this._value[i];
-        const p1 = this._value[i + 1];
-        const p2 = this._value[i + 2];
-        const p3 = this._value[i + 3];
-
-        const x = B0(t) * p0.x + B1(t) * p1.x + B2(t) * p2.x + B3(t) * p3.x;
-        const y = B0(t) * p0.y + B1(t) * p1.y + B2(t) * p2.y + B3(t) * p3.y;
-
-        return { x, y };
+    const keys = Object.keys(this.value)
+    let insertIndex = keys.length
+    for (let i = 0; i < keys.length; i++) {
+      if (normalizedPoint.x < this.value[keys[i]].x) {
+        insertIndex = i
+        break
+      }
+    }
+    // shift
+    for (let i = keys.length; i > insertIndex; i--) {
+      this.value[i] = this.value[i - 1]
    }

-    draw(ctx, node, width, posY, height) {
-        const [cw, ch] = this.computeSize(width)
+    this.value[insertIndex] = normalizedPoint
+  }

-        ctx.beginPath();
-        ctx.fillStyle = "#000";
-        //ctx.fillRect(0, posY, cw, ch);
-        ctx.strokeStyle = "#fff";
-        ctx.lineWidth = 2;
+  movePoint(index, localPos, width, height) {
+    const point = this.value[index]
+    point.x = Math.max(0, Math.min(1, localPos.x / width))
+    point.y = Math.max(0, Math.min(1, 1 - localPos.y / height))

-        // normalized coordinates -> canvas coordinates
-        for (let i = 0; i < this._value.length - 1; i++) {
-            let p1 = this._value[i];
-            let p2 = this._value[i + 1];
-            ctx.moveTo(p1.x * cw, posY + ch - p1.y * ch);
-            ctx.lineTo(p2.x * cw, posY + ch - p2.y * ch);
-        }
-        ctx.stroke();
-        // this.drawBSpline(ctx, width, height, posY);
+    this.value[index] = point
+  }
+  computeSize(width) {
+    return [width, 300]
+  }

-        // points
-        this._value.forEach(point => {
-            ctx.beginPath();
-            ctx.arc(point.x * cw, posY + ch - point.y * ch, 5, 0, 2 * Math.PI);
-            ctx.fill();
-        });
-    }
-
-    mouse(event, pos, node) {
-        // console.debug(event.type, pos, node)
-        let x = pos[0] - node.pos[0]
-        let y = pos[1] - node.pos[1]
-        let width = node.size[0]
-        const height = 300; // TODO: compute
-        const posY = node.pos[1];
-
-        const localPos = { x: pos[0], y: pos[1] - LiteGraph.NODE_WIDGET_HEIGHT };
-
-        if (event.type === LiteGraph.pointerevents_method + "down") {
-            console.debug("Checking if a point was clicked");
-            const clickedPointIndex = this.detectPoint(localPos, width, height);
-            if (clickedPointIndex !== null) {
-                this.selectedPointIndex = clickedPointIndex;
-            } else {
-                this.addPoint(localPos, width, height);
-            }
-            return true;
-        } else if (event.type === LiteGraph.pointerevents_method + "move" && this.selectedPointIndex !== null) {
-            this.movePoint(this.selectedPointIndex, localPos, width, height);
-            return true;
-        } else if (event.type === LiteGraph.pointerevents_method + "up" && this.selectedPointIndex !== null) {
-            this.selectedPointIndex = null;
-            return true;
-        }
-        return false;
-    }
-
-
-    detectPoint(localPos, width, height) {
-        const threshold = 20; // TODO: extract
-        for (let i = 0; i < this._value.length; i++) {
-            const p = this._value[i];
-            const px = p.x * width;
-            const py = height - p.y * height;
-            if (Math.abs(localPos.x - px) < threshold && Math.abs(localPos.y - py) < threshold) {
-                return i;
-            }
-        }
-        return null;
-    }
-
-    addPoint(localPos, width, height) {
-        // add a new point based on click position
-        const normalizedPoint = { x: localPos.x / width, y: 1 - localPos.y / height };
-        this._value.push(normalizedPoint);
-        this._value.sort((a, b) => a.x - b.x);
-        this.value = JSON.stringify(this._value);
-    }
-
-    movePoint(index, localPos, width, height) {
-        const point = this._value[index];
-        point.x = Math.max(0, Math.min(1, localPos.x / width));
-        point.y = Math.max(0, Math.min(1, 1 - localPos.y / height));
-
-        this._value[index] = point;
-        this.value = JSON.stringify(this._value);
-    }
-
-    computeSize(width) {
-        return [width, 300];
-    }
-
-    configure(data) {
-        console.log(data)
-    }
-
-    value() {
-        console.debug('Returning value', this._value)
-        return this._value
-    }
-    setValue(value) {
-        console.debug('Setting value', value)
-        this._value = value
-    }
+  configure(data) {
+  }
 }

 app.registerExtension({
-    name: 'mtb.curves',
-    getCustomWidgets: function () {
+  name: 'mtb.curves',
+  getCustomWidgets: () => {
+    return {
+      /**
+       * @param {LGraphNode} node
+       * @param {str} inputName
+       * @param {[str,*]} inputData
+       * @param {*} app
+       *
+       */
+      FLOAT_CURVE: (node, inputName, inputData, app) => {
+        // const c = node.widgets.find((w) => w.type === "FLOAT_CURVE")
+        const wid = node.addCustomWidget(new CurveWidget(inputName, inputData))
+
        return {
-            FLOAT_CURVE: (node, inputName, inputData, app) => {
-                console.debug('Registering float curve widget');
-
-                return {
-                    widget: node.addCustomWidget(
-                        new CurveWidget(inputName, inputData[1]?.default)
-                    ),
-                    minWidth: 150,
-                    minHeight: 30,
-                }
-            },
-
-
+          widget: wid,
+          minWidth: 150,
+          minHeight: 30,
        }
-    },
-
+      },
+    }
+  },
 })
@@ -7,10 +7,12 @@
 *
 */

+// Reference the shared typedefs file
+/// <reference path="../types/typedefs.js" />
+
 import { app } from '../../scripts/app.js'

 import * as shared from './comfy_shared.js'
-import { log } from './comfy_shared.js'
 import { MtbWidgets } from './mtb_widgets.js'

 // TODO: respect inputs order...
@@ -25,10 +27,17 @@ function escapeHtml(unsafe) {
 }
 app.registerExtension({
  name: 'mtb.Debug',
+
+  /**
+   * @param {NodeType} nodeType
+   * @param {NodeData} nodeData
+   * @param {*} app
+   */
  async beforeRegisterNodeDef(nodeType, nodeData, app) {
    if (nodeData.name === 'Debug (mtb)') {
      const onNodeCreated = nodeType.prototype.onNodeCreated
      nodeType.prototype.onNodeCreated = function () {
+        this.options = {}
        const r = onNodeCreated
          ? onNodeCreated.apply(this, arguments)
          : undefined
@@ -37,24 +46,29 @@ app.registerExtension({
      }

      const onConnectionsChange = nodeType.prototype.onConnectionsChange
-      nodeType.prototype.onConnectionsChange = function (
-        type,
-        index,
-        connected,
-        link_info,
-      ) {
+      /**
+       * @param {OnConnectionsChangeParams} args
+       */
+      nodeType.prototype.onConnectionsChange = function (...args) {
+        const [_type, index, connected, link_info, ioSlot] = args
        const r = onConnectionsChange
-          ? onConnectionsChange.apply(this, arguments)
+          ? onConnectionsChange.apply(this, args)
          : undefined
        // TODO: remove all widgets on disconnect once computed
-        shared.dynamic_connection(this, index, connected, 'anything_', '*')
+        shared.dynamic_connection(this, index, connected, 'anything_', '*', {
+          link: link_info,
+          ioSlot: ioSlot,
+        })

        //- infer type
        if (link_info) {
-          const fromNode = this.graph._nodes.find(
-            (otherNode) => otherNode.id == link_info.origin_id,
-          )
-          const type = fromNode.outputs[link_info.origin_slot].type
+          // const fromNode = this.graph._nodes.find(
+          // (otherNode) => otherNode.id === link_info.origin_id,
+          // )
+          // const fromNode = app.graph.getNodeById(link_info.origin_id)
+          const { from } = shared.nodesFromLink(this, link_info)
+          if (!from || this.inputs.length === 0) return
+          const type = from.outputs[link_info.origin_slot].type
          this.inputs[index].type = type
          // this.inputs[index].label = type.toLowerCase()
        }
@@ -67,14 +81,12 @@ app.registerExtension({
      }

      const onExecuted = nodeType.prototype.onExecuted
-      nodeType.prototype.onExecuted = function (message) {
+      nodeType.prototype.onExecuted = function (data) {
        onExecuted?.apply(this, arguments)

        const prefix = 'anything_'

        if (this.widgets) {
-          // const pos = this.widgets.findIndex((w) => w.name === "anything_1");
-          // if (pos !== -1) {
          for (let i = 0; i < this.widgets.length; i++) {
            if (this.widgets[i].name !== 'output_to_console') {
              this.widgets[i].onRemoved?.()
@@ -83,9 +95,9 @@ app.registerExtension({
          this.widgets.length = 1
        }
        let widgetI = 1
-
-        if (message.text) {
-          for (const txt of message.text) {
+        // console.log(message)
+        if (data.text) {
+          for (const txt of data.text) {
            const w = this.addCustomWidget(
              MtbWidgets.DEBUG_STRING(`${prefix}_${widgetI}`, escapeHtml(txt)),
            )
@@ -93,19 +105,17 @@ app.registerExtension({
            widgetI++
          }
        }
-        if (message.b64_images) {
-          for (const img of message.b64_images) {
+        if (data.b64_images) {
+          for (const img of data.b64_images) {
            const w = this.addCustomWidget(
              MtbWidgets.DEBUG_IMG(`${prefix}_${widgetI}`, img),
            )
            w.parent = this
            widgetI++
          }
-          // this.onResize?.(this.size);
-          // this.resize?.(this.size)
        }

-        this.setSize(this.computeSize())
+        // this.setSize(this.computeSize())

        this.onRemoved = function () {
          // When removing this node we need to remove the input from the DOM
@@ -11,7 +11,7 @@

 import { api } from '../../scripts/api.js'
 import { app } from '../../scripts/app.js'
-import { LocalStorageManager } from "./comfy_shared.js"
+import { LocalStorageManager } from './comfy_shared.js'
 const styles = {
  lighbox: {
    position: 'fixed',
@@ -53,9 +53,9 @@ let currentImageIndex = 0
 const imageUrls = []

 let image_menu = null
-const storage = new LocalStorageManager('mtb');
+const storage = new LocalStorageManager('mtb')

-let activated = storage.get("image_feed", true)
+let activated = storage.get('image_feed', false)

 app.registerExtension({
  name: 'mtb.ImageFeed',
@@ -71,19 +71,21 @@ app.registerExtension({
        },
      },
      async onChange(value) {
-        storage.set("image_feed", value)
+        storage.set('image_feed', value)
        activated = value
      },
    })
  },
  init: async () => {
-    if (!activated) { return }
+    if (!activated) {
+      return
+    }
    const pythongossFeed = app.extensions.find(
-      (e) => e.name == 'pysssss.ImageFeed'
+      (e) => e.name === 'pysssss.ImageFeed',
    )
    if (pythongossFeed) {
      console.warn(
-        "[mtb] - Aborting the loading of mtb's imageFeed in favor of pysssss.ImageFeed"
+        "[mtb] - Aborting the loading of mtb's imageFeed in favor of pysssss.ImageFeed",
      )
      activated = false // just in case other methods are added later on
      return
@@ -114,7 +116,7 @@ app.registerExtension({
    const lightboxCloseBtn = document.createElement('button')
    Object.assign(
      lightboxCloseBtn.style,
-      styles.lightboxBtn({ right: '0', top: '0' })
+      styles.lightboxBtn({ right: '0', top: '0' }),
    )
    lightboxCloseBtn.textContent = '❌'

@@ -184,7 +186,7 @@ app.registerExtension({
    //- append to DOM
    document.body.append(imageListContainer)

-    showBtn.textContent = '🖼️'
+    showBtn.textContent = '🖼'
    showBtn.onclick = () => {
      imageListContainer.style.display = 'block'
      showBtn.style.display = 'none'
@@ -250,8 +252,9 @@ app.registerExtension({
        objectFit: 'cover',
      })

-      img.src = `/view?filename=${encodeURIComponent(src.filename)}&type=${src.type
-        }&subfolder=${encodeURIComponent(src.subfolder)}`
+      img.src = `/view?filename=${encodeURIComponent(src.filename)}&type=${
+        src.type
+      }&subfolder=${encodeURIComponent(src.subfolder)}`

      imageUrls.push(img.src)

@@ -0,0 +1,246 @@
+// web/note_plus.constants.js
+
+export const DEFAULT_CSS = ''
+export const DEFAULT_HTML = `<p style='color:red;font-family:monospace'>
+    Note+
+</p>`
+export const DEFAULT_MD = '## Note+'
+export const DEFAULT_MODE = 'markdown'
+export const DEFAULT_THEME = 'one_dark'
+
+export const DEMO_CONTENT = `
+# @mtb/svelte-markdown.
+## This is a subheader
+
+[![embedded test](https://github.com/melMass/comfy_mtb/actions/workflows/test_embedded.yml/badge.svg)](https://github.com/melMass/comfy_mtb/actions/workflows/test_embedded.yml)
+![home](https://repository-images.githubusercontent.com/649047066/a3eef9a7-20dd-4ef9-b839-884502d4e873)
+
+<details>
+<summary>More details about the inception of the project</summary>
+
+\`\`\`js
+class YesMan{
+  constructor(){
+    this.started = false
+  }
+}
+\`\`\`
+</details>
+
+This is a paragraph. If it goes over the maximum width it will not automatically wrap unless it reaches the max-w of \`prose\` check [styles](/styles) for more info.
+
+This component is useful for building some tools on top. Or even just a static system using svelte at its core. My personal blog is fully powered by **@mtb/svelte-markdown**
+
+| And this is | A table |
+|-------------|---------|
+| With two    | columns |
+
+We also support github callout:
+
+
+> [!NOTE]
+> Highlights information that users should take into account, even when skimming.
+> [!TIP]
+> Optional information to help a user be more successful.
+
+
+> [!IMPORTANT]
+> Crucial information necessary for users to succeed.
+
+> [!WARNING]
+> Critical content demanding immediate user attention due to potential risks.
+
+> [!CAUTION]
+> Negative potential consequences of an action.
+`
+
+export const THEMES = [
+	'ambiance',
+	'chaos',
+	'chrome',
+	'cloud9_day',
+	'cloud9_night',
+	'cloud9_night_low_color',
+	'cloud_editor',
+	'cloud_editor_dark',
+	'clouds',
+	'clouds_midnight',
+	'cobalt',
+	'crimson_editor',
+	'dawn',
+	'dracula',
+	'dreamweaver',
+	'eclipse',
+	'github',
+	'github_dark',
+	'gob',
+	'gruvbox',
+	'gruvbox_dark_hard',
+	'gruvbox_light_hard',
+	'idle_fingers',
+	'iplastic',
+	'katzenmilch',
+	'kr_theme',
+	'kuroir',
+	'merbivore',
+	'merbivore_soft',
+	'mono_industrial',
+	'monokai',
+	'nord_dark',
+	'one_dark',
+	'pastel_on_dark',
+	'solarized_dark',
+	'solarized_light',
+	'sqlserver',
+	'terminal',
+	'textmate',
+	'tomorrow',
+	'tomorrow_night',
+	'tomorrow_night_blue',
+	'tomorrow_night_bright',
+	'tomorrow_night_eighties',
+	'twilight',
+	'vibrant_ink',
+	'vscode',
+]
+
+export const CSS_RESET = `
+* {
+  font-family: monospace;
+  line-height: 1.25em;
+}
+.shiki{
+    padding: 1em;
+    width: 100%;
+}
+.markdown-callout-title {
+    .octicon{
+        fill:white;
+    }
+	/* background: var(--current-color); */
+	color: var(--current-color);
+	font-weight: bold;
+	/* border-start-end-radius: var(--radius); */
+	/* border-start-start-radius: var(--radius); */
+	padding: 0.5em;
+	padding-inline-start: 1em;
+}
+.markdown-callout-content {
+	padding: 1em;
+}
+.markdown-callout {
+	--radius: 8px;
+	--current-color: purple;
+	/* border-start-end-radius: var(--radius); */
+	/* border-start-start-radius: var(--radius); */
+	border-left: 3px solid var(--current-color);
+	margin-bottom: 1em;
+	margin-top: 1em;
+}
+
+.markdown-callout-tip {
+	--text-color: whitesmoke;
+	--current-color: #50e3c2;
+}
+
+.markdown-callout-note {
+	--text-color: whitesmoke;
+	--current-color: #0070f3;
+}
+.markdown-callout-important {
+	--text-color: whitesmoke;
+	--current-color: #7928ca;
+}
+.markdown-callout-warning {
+	--current-color: #f5a623;
+}
+.markdown-callout-caution {
+	--current-color: #e60000;
+}
+
+
+.note-plus-preview {
+  display:flex;
+  flex-direction:column;
+  align-items: flex-start;
+  width:95%;
+  margin-left: 20px;
+  margin-top:20px;
+  /*background-color: rgba(255,0,0,0.5)!important;*/
+}
+
+/* allowed to be selected*/
+h1, h2, h3, h4, h5, h6,a, p, ul, ol, dl, blockquote,details,summary  {
+  pointer-events:auto;
+  user-select:text;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  display:inline-block;
+  margin: 0;
+  padding: 0;
+  font-weight: normal;
+}
+
+p, ul, ol, dl, blockquote {
+  margin: 0.3em;
+  padding: 0;
+}
+
+ul, ol {
+  padding-left: 1em;
+}
+
+a {
+  color: inherit;
+  text-decoration: none;
+  pointer-events: all;
+  color: cyan;
+}
+
+img {
+  padding: 1em 0;
+  max-width: 100%;
+}
+
+iframe {
+  max-width: 100%;
+  height: auto;
+  border:none;
+  pointer-events:all;
+}
+
+blockquote {
+  border-left: 4px solid #ccc;
+  padding-left: 1em;
+  margin-left: 0;
+  font-style: italic;
+}
+
+pre, code {
+  font-family: monospace;
+}
+
+table {
+  border-collapse: collapse;
+  width: 100%;
+  border-bottom: 1px solid #000;
+  margin: 1em 0;
+}
+
+th, td {
+  border-left: 1px solid #000;
+  border-right: 1px solid #000;
+  padding: 8px;
+  text-align: left;
+}
+
+th {
+  border: 1px solid #000;
+  background-color: rgba(0,0,0,0.5);
+}
+
+input[type="checkbox"] {
+  margin-right: 10px;
+}
+`
@@ -1,158 +1,122 @@
+/// <reference path="../types/typedefs.js" />
+
 import { app } from '../../scripts/app.js'
+
 import * as shared from './comfy_shared.js'
 import { infoLogger, successLogger, errorLogger } from './comfy_shared.js'
+import {
+  DEFAULT_CSS,
+  DEFAULT_HTML,
+  DEFAULT_MD,
+  DEFAULT_MODE,
+  DEFAULT_THEME,
+  THEMES,
+  CSS_RESET,
+  DEMO_CONTENT,
+} from './note_plus.constants.js'
+import { LocalStorageManager } from './comfy_shared.js'

-const DEFAULT_CSS = ''
-const DEFAULT_HTML = `<p style='color:red;font-family:monospace'>
-    Note+
-</p>`
-const DEFAULT_MD = '## Note+'
-const DEFAULT_MODE = 'markdown'
-const DEFAULT_THEME = 'one_dark'
+const storage = new LocalStorageManager('mtb')

-const CSS_RESET = `
-* {
-  font-family: monospace;
-  line-height: 1.25em;
+/**
+ * Uses `@mtb/markdown-parser` (a fork of marked)
+ * It is statically stored to avoid having
+ * more than 1 instance ever.
+ * The size difference between both libraries...
+ * ╭───┬────────────────────────────────┬──────────╮
+ * │ # │              name              │   size   │
+ * ├───┼────────────────────────────────┼──────────┤
+ * │ 0 │ web-dist/mtb_markdown_plus.mjs │   1.2 MB │ <- with shiki
+ * │ 1 │ web-dist/mtb_markdown.mjs      │  44.7 KB │
+ * ╰───┴────────────────────────────────┴──────────╯
+ */
+let useShiki = storage.get('np-use-shiki', false)
+
+const makeResizable = (dialog) => {
+  dialog.style.resize = 'both'
+  dialog.style.transformOrigin = 'top left'
+  dialog.style.overflow = 'auto'
 }

-h1, h2, h3, h4, h5, h6 {
-  margin: 0;
-  padding: 0;
-  font-weight: normal;
+const makeDraggable = (dialog, handle) => {
+  let offsetX = 0
+  let offsetY = 0
+  let isDragging = false
+
+  const onMouseMove = (e) => {
+    if (isDragging) {
+      dialog.style.left = `${e.clientX - offsetX}px`
+      dialog.style.top = `${e.clientY - offsetY}px`
+    }
+  }
+
+  const onMouseUp = () => {
+    isDragging = false
+    document.removeEventListener('mousemove', onMouseMove)
+    document.removeEventListener('mouseup', onMouseUp)
+  }
+
+  handle.addEventListener('mousedown', (e) => {
+    isDragging = true
+    offsetX = e.clientX - dialog.offsetLeft
+    offsetY = e.clientY - dialog.offsetTop
+    document.addEventListener('mousemove', onMouseMove)
+    document.addEventListener('mouseup', onMouseUp)
+  })
 }

-p, ul, ol, dl, blockquote {
-  margin: 0.3em;
-  padding: 0;
-}
-
-
-ul, ol {
-  
-  padding-left: 1em;
-  
-}
-
-a {
-  color: inherit;
-  text-decoration: none;
-  pointer-events: all;
-  color: cyan;
-}
-
-img {
-  padding: 1em 0;
-  max-width: 100%;
-}
-
-iframe {
-  width: 100%;
-  height: auto;
-  border:none;
-  pointer-events:all;
-}
-
-blockquote {
-  border-left: 4px solid #ccc;
-  padding-left: 1em;
-  margin-left: 0;
-  font-style: italic;
-}
-
-pre, code {
-  font-family: monospace;
-}
-
-table {
-  border-collapse: collapse;
-  width: 100%;
-  border-bottom: 1px solid #000;
-  margin: 1em 0;
-}
-
-th, td {
-  border-left: 1px solid #000;
-  border-right: 1px solid #000;
-  padding: 8px;
-  text-align: left;
-}
-
-th {
-  border: 1px solid #000;
-
-  background-color: rgba(0,0,0,0.5);
-}
-
-input[type="checkbox"] {
-  margin-right: 10px;
-}
-
-`
-
-const themes = [
-  'ambiance',
-  'chaos',
-  'chrome',
-  'cloud9_day',
-  'cloud9_night',
-  'cloud9_night_low_color',
-  'cloud_editor',
-  'cloud_editor_dark',
-  'clouds',
-  'clouds_midnight',
-  'cobalt',
-  'crimson_editor',
-  'dawn',
-  'dracula',
-  'dreamweaver',
-  'eclipse',
-  'github',
-  'github_dark',
-  'gob',
-  'gruvbox',
-  'gruvbox_dark_hard',
-  'gruvbox_light_hard',
-  'idle_fingers',
-  'iplastic',
-  'katzenmilch',
-  'kr_theme',
-  'kuroir',
-  'merbivore',
-  'merbivore_soft',
-  'mono_industrial',
-  'monokai',
-  'nord_dark',
-  'one_dark',
-  'pastel_on_dark',
-  'solarized_dark',
-  'solarized_light',
-  'sqlserver',
-  'terminal',
-  'textmate',
-  'tomorrow',
-  'tomorrow_night',
-  'tomorrow_night_blue',
-  'tomorrow_night_bright',
-  'tomorrow_night_eighties',
-  'twilight',
-  'vibrant_ink',
-  'vscode',
-]
+/** @extends {LGraphNode} */
 class NotePlus extends LiteGraph.LGraphNode {
-  title = 'Note+ (mtb)'
-  category = 'mtb/utils'
-
  // same values as the comfy note
  color = LGraphCanvas.node_colors.yellow.color
  bgcolor = LGraphCanvas.node_colors.yellow.bgcolor
  groupcolor = LGraphCanvas.node_colors.yellow.groupcolor

+  /* NOTE: this is not serialized and only there to make multiple
+   *  note+ nodes in the same graph unique.
+   */
+  uuid
+
+  /** Stores the dialog observer*/
+  resizeObserver
+
+  /** Live update the preview*/
+  live = true
+  /** DOM height by adding child size together*/
+  calculated_height = 0
+
+  /** ????*/
+  _raw_html
+
+  /** might not be needed anymore */
+  inner
+
+  /** the dialog DOM widget*/
+  dialog
+
+  /** widgets*/
+
+  /** used to store the raw value and display the parsed html at the same time*/
+  html_widget
+
+  /** hidden widgets for serialization*/
+  css_widget
+  edit_mode_widget
+  theme_widget
+
+  editorsContainer
+  /** ACE editors instances*/
+  html_editor
+  css_editor
+
  constructor() {
    super()
    this.uuid = shared.makeUUID()

    infoLogger('Constructing Note+ instance')
+    shared.ensureMarkdownParser((_p) => {
+      this.updateHTML()
+    })
    // - litegraph settings
    this.collapsable = true
    this.isVirtualNode = true
@@ -162,35 +126,30 @@ class NotePlus extends LiteGraph.LGraphNode {
    // - default values, serialization is done through widgets
    this._raw_html = DEFAULT_MODE === 'html' ? DEFAULT_HTML : DEFAULT_MD

-    // - mardown converter
-    this.markdownConverter = new showdown.Converter({
-      tables: true,
-      strikethrough: true,
-      emoji: true,
-      ghCodeBlocks: true,
-      tasklists: true,
-      ghMentions: true,
-      smoothLivePreview: true,
-      simplifiedAutoLink: true,
-      parseImgDimensions: true,
-      openLinksInNewWindow: true,
-    })
-
    // - state
    this.live = true
    this.calculated_height = 0

    // - add widgets
-    const inner = document.createElement('div')
-    inner.style.margin = '0'
-    inner.style.padding = '0'
-    inner.style.pointerEvents = 'none'
-    this.html_widget = this.addDOMWidget('HTML', 'html', inner, {
+    const cinner = document.createElement('div')
+    this.inner = document.createElement('div')
+
+    cinner.append(this.inner)
+    this.inner.classList.add('note-plus-preview')
+    cinner.style.margin = '0'
+    cinner.style.padding = '0'
+    this.html_widget = this.addDOMWidget('HTML', 'html', cinner, {
      setValue: (val) => {
        this._raw_html = val
      },
      getValue: () => this._raw_html,
      getMinHeight: () => this.calculated_height, // (the edit button),
+      onDraw: () => {
+        // HACK: dirty hack for now until it's addressed upstream...
+        this.html_widget.element.style.pointerEvents = 'none'
+        // NOTE: not sure about this, it avoid the visual "bugs" but scrolling over the wrong area will affect zoom...
+        // this.html_widget.element.style.overflow = 'scroll'
+      },
      hideOnZoom: false,
    })

@@ -200,22 +159,48 @@ class NotePlus extends LiteGraph.LGraphNode {
  }

  /**
-   *
-   * @param {CanvasRenderingContext2D} ctx
-   * @param {LGraphCanvas} graphcanvas
-   * @returns
+   * @param {CanvasRenderingContext2D} ctx canvas context
+   * @param {any} _graphcanvas
   */
-
  onDrawForeground(ctx, _graphcanvas) {
    if (this.flags.collapsed) return
+    this.drawEditIcon(ctx)
+    this.drawSideHandle(ctx)

-    // Define the size and position of the icon
-    const iconSize = 14 // Size of the icon
-    const iconMargin = 8 // Margin from the edges
-    const x = this.size[0] - iconSize - iconMargin
-    const y = iconMargin * 1.5
+    // DEBUG BACKGROUND
+    // ctx.fillStyle = 'rgba(0, 255, 0, 0.3)'
+    // const rect = this.rect
+    // ctx.fillRect(rect.x, rect.y, rect.width, rect.height)
+  }
+  drawSideHandle(ctx) {
+    const handleRect = this.sideHandleRect
+    const chamfer = 20
+    ctx.beginPath()
+
+    // top left
+    ctx.moveTo(handleRect.x, handleRect.y + chamfer)
+    // top right
+    ctx.lineTo(handleRect.x + handleRect.width, handleRect.y)
+
+    // bottom right
+    ctx.lineTo(
+      handleRect.x + handleRect.width,
+      handleRect.y + handleRect.height,
+    )
+    // bottom left
+    ctx.lineTo(handleRect.x, handleRect.y + handleRect.height - chamfer)
+    ctx.closePath()
+
+    ctx.fillStyle = 'rgba(255, 255, 255, 0.05)'
+    ctx.fill()
+  }
+
+  drawEditIcon(ctx) {
+    const rect = this.iconRect
+    // DEBUG ICON POSITION
+    // ctx.fillStyle = 'rgba(0, 255, 0, 0.3)'
+    // ctx.fillRect(rect.x, rect.y, rect.width, rect.height)

-    // Create a new Path2D object from SVG path data
    const pencilPath = new Path2D(
      'M21.28 6.4l-9.54 9.54c-.95.95-3.77 1.39-4.4.76-.63-.63-.2-3.45.75-4.4l9.55-9.55a2.58 2.58 0 1 1 3.64 3.65z',
    )
@@ -223,41 +208,73 @@ class NotePlus extends LiteGraph.LGraphNode {
      'M11 4H6a4 4 0 0 0-4 4v10a4 4 0 0 0 4 4h11c2.21 0 3-1.8 3-4v-5',
    )

-    // Draw the paths
    ctx.save()
-    ctx.translate(x, y) // Position the icon on the canvas
-    ctx.scale(iconSize / 32, iconSize / 32) // Scale the icon to the desired size
-    ctx.strokeStyle = 'rgba(255,255,255,0.3)'
-
+    ctx.translate(rect.x, rect.y)
+    ctx.scale(rect.width / 32, rect.height / 32)
+    ctx.strokeStyle = 'rgba(255,255,255,0.4)'
    ctx.lineCap = 'round'
    ctx.lineJoin = 'round'
-
    ctx.lineWidth = 2.4
    ctx.stroke(pencilPath)
    ctx.stroke(folderPath)
    ctx.restore()
  }
-  onMouseDown(_e, localPos, _graphcanvas) {
-    // Check if the click is within the pencil icon bounds
-    const iconSize = 14
-    const iconMargin = 8
-    const iconX = this.size[0] - iconSize - iconMargin
-    const iconY = iconMargin * 1.5
-
-    if (
-      localPos[0] > iconX &&
-      localPos[0] < iconX + iconSize &&
-      localPos[1] > iconY &&
-      localPos[1] < iconY + iconSize
-    ) {
-      // Pencil icon was clicked, open the editor
-      this.openEditorDialog()
-      return true // Return true to indicate the event was handled
+  /**
+   * @param {number} x
+   * @param {number} y
+   * @param {{x:number,y:number,width:number,height:number}} rect
+   * @returns {}
+   */
+  inRect(x, y, rect) {
+    rect = rect || this.iconRect
+    return (
+      x >= rect.x &&
+      x <= rect.x + rect.width &&
+      y >= rect.y &&
+      y <= rect.y + rect.height
+    )
+  }
+  get rect() {
+    return {
+      x: 0,
+      y: 0,
+      width: this.size[0],
+      height: this.size[1],
    }
+  }
+  get sideHandleRect() {
+    const w = this.size[0]
+    const h = this.size[1]

-    return false // Return false to let the event propagate
+    const bw = 32
+    const bho = 64
+
+    return {
+      x: w - bw,
+      y: bho,
+      width: bw,
+      height: h - bho * 1.5,
+    }
+  }
+  get iconRect() {
+    const iconSize = 32
+    const iconMargin = 16
+    return {
+      x: this.size[0] - iconSize - iconMargin,
+      y: iconMargin * 1.5,
+      width: iconSize,
+      height: iconSize,
+    }
+  }
+  onMouseDown(_e, localPos, _graphcanvas) {
+    if (this.inRect(localPos[0], localPos[1])) {
+      this.openEditorDialog()
+      return true
+    }
+    return false
  }

+  /* Hidden widgets to store note+ settings in the workflow (stripped in API)*/
  setupSerializationWidgets() {
    infoLogger('Setup Serializing widgets')

@@ -286,15 +303,36 @@ class NotePlus extends LiteGraph.LGraphNode {
    shared.hideWidgetForGood(this, this.css_widget)
    shared.hideWidgetForGood(this, this.theme_widget)
  }
+
  setupDialog() {
    infoLogger('Setup dialog')
-    // this.addWidget('button', 'Edit', 'Edit', this.openEditorDialog.bind(this))

    this.dialog = new app.ui.dialog.constructor()
    this.dialog.element.classList.add('comfy-settings')

+    Object.assign(this.dialog.element.style, {
+      position: 'absolute',
+      boxShadow: 'none',
+    })
+
+    const subcontainer = this.dialog.textElement.parentElement
+
+    if (subcontainer) {
+      Object.assign(subcontainer.style, {
+        width: '100%',
+      })
+    }
    const closeButton = this.dialog.element.querySelector('button')
    closeButton.textContent = 'CANCEL'
+    closeButton.id = 'cancel-editor-dialog'
+    closeButton.title =
+      "Cancel the changes since last opened (doesn't support live mode)"
+    closeButton.disabled = this.live
+
+    closeButton.style.background = this.live
+      ? 'repeating-linear-gradient(45deg,#606dbc,#606dbc 10px,#465298 10px,#465298 20px)'
+      : ''
+
    const saveButton = document.createElement('button')
    saveButton.textContent = 'SAVE'
    saveButton.onclick = () => {
@@ -316,32 +354,54 @@ class NotePlus extends LiteGraph.LGraphNode {

  closeEditorDialog(accept) {
    infoLogger('Closing editor dialog', accept)
-    if (accept) {
+    if (accept && !this.live) {
      this.updateHTML(this.html_editor.getValue())
      this.updateCSS(this.css_editor.getValue())
    }
+    if (this.resizeObserver) {
+      this.resizeObserver.disconnect()
+      this.resizeObserver = null
+    }
    this.teardownEditors()
    this.dialog.close()
  }

+  /**
+   * @param {HTMLElement} elem
+   */
+  hookResize(elem) {
+    if (!this.resizeObserver) {
+      const observer = () => {
+        this.html_editor.resize()
+        this.css_editor.resize()
+        Object.assign(this.editorsContainer.style, {
+          minHeight: `${(this.dialog.element.clientHeight / 100) * 50}px`, //'200px',
+        })
+      }
+      this.resizeObserver = new ResizeObserver(observer).observe(elem)
+    }
+  }
  openEditorDialog() {
    infoLogger(`Current edit mode ${this.edit_mode_widget.value}`)
+    this.hookResize(this.dialog.element)
    const container = document.createElement('div')
-
    Object.assign(container.style, {
      display: 'flex',
      gap: '10px',
      flexDirection: 'column',
    })

-    const editorsContainer = document.createElement('div')
-    Object.assign(editorsContainer.style, {
+    this.editorsContainer = document.createElement('div')
+
+    Object.assign(this.editorsContainer.style, {
      display: 'flex',
      gap: '10px',
      flexDirection: 'row',
+      minHeight: this.dialog.element.offsetHeight, //'200px',
+      width: '100%',
    })

-    container.append(editorsContainer)
+    container.append(this.editorsContainer)

    this.dialog.show('')
    this.dialog.textElement.append(container)
@@ -349,30 +409,39 @@ class NotePlus extends LiteGraph.LGraphNode {
    const aceHTML = document.createElement('div')
    aceHTML.id = 'noteplus-html-editor'
    Object.assign(aceHTML.style, {
-      width: '300px',
-      height: '300px',
-      // backgroundColor: 'rgb(30,30,30)',
-      // color: 'whitesmoke',
+      width: '100%',
+      height: '100%',
+
+      minWidth: '300px',
+      minHeight: 'inherit',
    })

-    editorsContainer.append(aceHTML)
+    this.editorsContainer.append(aceHTML)

    const aceCSS = document.createElement('div')
    aceCSS.id = 'noteplus-css-editor'
    Object.assign(aceCSS.style, {
-      width: '300px',
-      height: '300px',
-      // backgroundColor: 'rgb(30,30,30)',
-      // color: 'whitesmoke',
+      width: '100%',
+      height: '100%',
+      minHeight: 'inherit',
    })

-    editorsContainer.append(aceCSS)
+    this.editorsContainer.append(aceCSS)

    const live_edit = document.createElement('input')
    live_edit.type = 'checkbox'
    live_edit.checked = this.live
    live_edit.onchange = () => {
      this.live = live_edit.checked
+      const cancel_button = this.dialog.element.querySelector(
+        '#cancel-editor-dialog',
+      )
+      if (cancel_button) {
+        cancel_button.disabled = this.live
+        cancel_button.style.background = this.live
+          ? 'repeating-linear-gradient(45deg,#606dbc,#606dbc 10px,#465298 10px,#465298 20px)'
+          : ''
+      }
    }

    //- "Dynamic" elements
@@ -391,15 +460,14 @@ class NotePlus extends LiteGraph.LGraphNode {
            const md = this.html_editor.getValue()
            this.edit_mode_widget.value = 'html'
            select_mode.value = 'html'
-            const html = this.markdownConverter.makeHtml(md)
-            this.html_widget.value = html
-            this.html_editor.setValue(html)
-            this.html_editor.session.setMode('ace/mode/html')
-            this.updateHTML(this.html_widget.value)
-
-            convert_to_html.remove()
+            MTB.mdParser.parse(md).then((content) => {
+              this.html_widget.value = content
+              this.html_editor.setValue(content)
+              this.html_editor.session.setMode('ace/mode/html')
+              this.updateHTML(this.html_widget.value)
+              convert_to_html.remove()
+            })
          }
-
          firstButton.before(convert_to_html)
        }
      } else {
@@ -409,6 +477,19 @@ class NotePlus extends LiteGraph.LGraphNode {
        }
      }
      select_mode.value = this.edit_mode_widget.value
+
+      // the header for dragging the dialog
+      const header = document.createElement('div')
+      header.style.padding = '8px'
+      header.style.cursor = 'move'
+      header.style.backgroundColor = 'rgba(0,0,0,0.5)'
+      header.style.userSelect = 'none'
+
+      header.style.borderBottom = '1px solid #ddd'
+      header.textContent = 'MTB Note+ Editor'
+      container.prepend(header)
+      makeDraggable(this.dialog.element, header)
+      makeResizable(this.dialog.element)
    }
    //- combobox
    let theme_select = this.dialog.element.querySelector('#theme_select')
@@ -424,7 +505,7 @@ class NotePlus extends LiteGraph.LGraphNode {
        option.textContent = label
        theme_select.append(option)
      }
-      for (const t of themes) {
+      for (const t of THEMES) {
        addOption(t)
      }

@@ -487,65 +568,66 @@ class NotePlus extends LiteGraph.LGraphNode {
    this.setupEditors()
  }
  loadAceEditor() {
-    shared
-      .loadScript(
-        'https://cdn.jsdelivr.net/npm/ace-builds@1.16.0/src-min-noconflict/ace.min.js',
-      )
-      .catch((e) => {
-        errorLogger(e)
-      })
+    shared.loadScript('/mtb_async/ace/ace.js').catch((e) => {
+      errorLogger(e)
+    })
  }
  onCreate() {
    errorLogger('NotePlus onCreate')
  }
-  configure(info) {
-    super.configure(info)
-    infoLogger('Restoring serialized values', info)
-    // - update view from serialzed data
+  restoreNodeState(info) {
    this.html_widget.element.id = `note-plus-${this.uuid}`
    this.setMode(this.edit_mode_widget.value)
    this.setTheme(this.theme_widget.value)
    this.updateHTML(this.html_widget.value)
    this.updateCSS(this.css_widget.value)
-    this.setSize(info.size)
+    if (info?.size) {
+      this.setSize(info.size)
+    }
+  }
+  configure(info) {
+    super.configure(info)
+    infoLogger('Restoring serialized values', info)
+    this.restoreNodeState(info)
+    // - update view from serialzed data
  }
  onNodeCreated() {
    infoLogger('Node created', this.uuid)
-    this.html_widget.element.id = `note-plus-${this.uuid}`
-    this.setMode(this.edit_mode_widget.value)
-    this.setTheme(this.theme_widget.value)
-    this.updateHTML(this.html_widget.value) // widget is populated here since we called super
-    this.updateCSS(this.css_widget.value)
+    this.restoreNodeState({})
+    // this.html_widget.element.id = `note-plus-${this.uuid}`
+    // this.setMode(this.edit_mode_widget.value)
+    // this.setTheme(this.theme_widget.value)
+    // this.updateHTML(this.html_widget.value) // widget is populated here since we called super
+    // this.updateCSS(this.css_widget.value)
  }
  onRemoved() {
    infoLogger('Node removed', this.uuid)
  }
  getExtraMenuOptions() {
-    const options = []
-    // {
-    //       content: string;
-    //       callback?: ContextMenuEventListener;
-    //       /** Used as innerHTML for extra child element */
-    //       title?: string;
-    //       disabled?: boolean;
-    //       has_submenu?: boolean;
-    //       submenu?: {
-    //           options: ContextMenuItem[];
-    //       } & IContextMenuOptions;
-    //       className?: string;
-    //   }
-    options.push({
-      content: `Set to ${
-        this.edit_mode_widget.value === 'html' ? 'markdown' : 'html'
-      }`,
-      callback: () => {
-        this.edit_mode_widget.value =
-          this.edit_mode_widget.value === 'html' ? 'markdown' : 'html'
-        this.updateHTML(this.html_widget.value)
-      },
-    })
+    const currentMode = this.edit_mode_widget.value
+    const newMode = currentMode === 'html' ? 'markdown' : 'html'

-    return options
+    const debugItems = window.MTB?.DEBUG
+      ? [
+          {
+            content: 'Replace with demo content (debug)',
+            callback: () => {
+              this.html_widget.value = DEMO_CONTENT
+            },
+          },
+        ]
+      : []
+
+    return [
+      ...debugItems,
+      {
+        content: `Set to ${newMode}`,
+        callback: () => {
+          this.edit_mode_widget.value = newMode
+          this.updateHTML(this.html_widget.value)
+        },
+      },
+    ]
  }

  _setupEditor(editor) {
@@ -670,17 +752,44 @@ class NotePlus extends LiteGraph.LGraphNode {
    // this.setSize(this.computeSize())
  }

-  updateHTML(val) {
-    const cleanHTML = DOMPurify.sanitize(val, { ADD_TAGS: ['iframe'] })
-    this.html_widget.value = cleanHTML
+  parserInitiated() {
+    if (window.MTB?.mdParser) return true
+    return false
+  }

-    // update our widget preview
-    if (this.edit_mode_widget.value === 'html') {
-      this.html_widget.element.innerHTML = cleanHTML
-    } else if (this.edit_mode_widget.value === 'markdown') {
-      this.html_widget.element.innerHTML =
-        this.markdownConverter.makeHtml(cleanHTML)
+  /** to easilty swap purification methods*/
+  purify(content) {
+    return DOMPurify.sanitize(content, {
+      ADD_TAGS: ['iframe', 'detail', 'summary'],
+    })
+  }
+
+  updateHTML(val) {
+    if (!this.parserInitiated()) {
+      return
    }
+    val = val || this.html_widget.value
+    const isHTML = this.edit_mode_widget.value === 'html'
+
+    const cleanHTML = this.purify(val)
+
+    const value = isHTML
+      ? cleanHTML
+      : cleanHTML.replaceAll('&gt;', '>').replaceAll('&lt;', '<')
+    // .replaceAll('&amp;', '&')
+    // .replaceAll('&quot;', '"')
+    // .replaceAll('&#039;', "'")
+
+    this.html_widget.value = value
+
+    if (isHTML) {
+      this.inner.innerHTML = value
+    } else {
+      MTB.mdParser.parse(value).then((e) => {
+        this.inner.innerHTML = e
+      })
+    }
+    // this.html_widget.element.innerHTML = `<div id="note-plus-spacer"></div>${value}`
    this.calculateHeight()
    // this.setSize(this.computeSize())
  }
@@ -688,10 +797,34 @@ class NotePlus extends LiteGraph.LGraphNode {

 app.registerExtension({
  name: 'mtb.noteplus',
+  setup: () => {
+    app.ui.settings.addSetting({
+      id: 'mtb.noteplus.use-shiki',
+      category: ['mtb', 'Note+', 'use-shiki'],
+      name: 'Use shiki to highlight code',
+      tooltip:
+        'This will load a larger version of @mtb/markdown-parser that bundles shiki, it supports all shiki transformers (supported langs: html,css,python,markdown)',
+
+      type: 'boolean',
+      defaultValue: false,
+      attrs: {
+        style: {
+          // fontFamily: 'monospace',
+        },
+      },
+      async onChange(value) {
+        storage.set('np-use-shiki', value)
+        useShiki = value
+      },
+    })
+  },

  registerCustomNodes() {
    LiteGraph.registerNodeType('Note Plus (mtb)', NotePlus)

+    NotePlus.category = 'mtb/utils'
+    NotePlus.title = 'Note+ (mtb)'
+
    NotePlus.title_mode = LiteGraph.NO_TITLE
  },
 })
@@ -0,0 +1,334 @@
+// This is a vanillajs implementation of Houdini's number input widgets.
+// It basically popup a visual sensitivity slider of steps to use as incr/decr
+// TODO: Convert it to IWidget
+
+// import styles from "./style.module.css";
+
+function getValidNumber(numberInput) {
+  let num =
+    isNaN(numberInput.value) || numberInput.value === ''
+      ? 0
+      : parseFloat(numberInput.value)
+  return num
+}
+/**
+ * Number input widgets
+ */
+export class NumberInputWidget {
+  constructor(containerId, numberOfInputs = 1, isDebug = false) {
+    this.container = document.getElementById(containerId)
+    this.numberOfInputs = numberOfInputs
+    this.currentInput = null // Store the currently active input
+
+    this.threshold = 30
+    this.mouseSensitivityMultiplier = 0.05
+    this.debug = isDebug
+
+    //- states
+    this.initialMouseX
+    this.lastMouseX
+    this.activeStep = 1
+    this.accumulatedDelta = 0
+    this.stepLocked = false
+    this.thresholdExceeded = false
+    this.isDragging = false
+
+    const styleTagId = 'mtb-constant-style'
+
+    let styleTag = document.head.querySelector(`#${styleTagId}`)
+
+    if (!styleTag) {
+      styleTag = document.createElement('style')
+      styleTag.type = 'text/css'
+      styleTag.id = styleTagId
+
+      styleTag.innerHTML = `
+
+.${containerId}{
+  margin-top: 20px;
+  margin-bottom: 20px;
+}
+.sensitivity-menu {
+  display: none;
+  position: absolute;
+  /* Additional styling */
+}
+
+.sensitivity-menu .step {
+  cursor: pointer;
+  padding: 0.5em;
+  /* Add more styling as needed */
+}
+
+.sensitivity-menu {
+  font-family: monospace;
+
+  background: var(--bg-color);
+  border: 1px solid var(--fg-color); 
+  /* Highlight for the active step */
+}
+.number-input {
+  background: var(--bg-color);
+  color: var(--fg-color)
+}
+
+.sensitivity-menu .step.active {
+  background-color:var(--drag-text); 
+  /* Highlight for the active step */
+}
+
+.sensitivity-menu .step.locked {
+  background-color: #f00;
+  /* Change to your preferred color for the locked state */
+}
+#debug-container {
+  transform: translateX(50%);
+  width: 50%;
+  text-align: center;
+  font-family: monospace;
+}
+`
+      document.head.appendChild(styleTag)
+    }
+
+    this.createWidgetElements()
+    this.initializeEventListeners()
+  }
+
+  setLabel(str) {
+    this.label.textContent = str
+  }
+  setValue(...values) {
+    if (values.length !== this.numberInputs.length) {
+      console.error('Number of values does not match the number of inputs.')
+      console.error(
+        `You provided ${values.length} but the input want ${this.numberInputs.length}`,
+        { values },
+      )
+      return
+    }
+    // Set each input value
+    this.numberInputs.forEach((input, index) => {
+      input.value = values[index]
+    })
+  }
+  getValue() {
+    const value = []
+    this.numberInputs.forEach((input, index) => {
+      value.push(Number.parseFloat(input.value) || 0.0)
+    })
+    return value
+  }
+  resetValues() {
+    for (const input of numberInputs) {
+      input.value = 0
+    }
+    this.onChange?.(this.getValue())
+  }
+
+  createWidgetElements() {
+    this.label = document.createElement('label')
+    this.label.textContent = 'Control All:'
+    this.label.className = 'widget-label'
+    this.container.appendChild(this.label)
+
+    this.label.addEventListener('mousedown', (event) => {
+      if (event.button === 1) {
+        this.currentInput = null
+        this.handleMouseDown(event)
+      }
+    })
+
+    this.label.addEventListener('contextmenu', (event) => {
+      event.preventDefault()
+      this.resetValues()
+    })
+
+    this.numberInputs = []
+
+    // create linked inputs
+    for (let i = 0; i < this.numberOfInputs; i++) {
+      const numberInput = document.createElement('input')
+      numberInput.type = 'number'
+      numberInput.className = 'number-input' //styles.numberInput; //"number-input";
+      numberInput.step = 'any'
+      this.container.appendChild(numberInput)
+      this.numberInputs.push(numberInput)
+
+      numberInput.addEventListener('mousedown', (event) => {
+        if (event.button === 1) {
+          this.currentInput = numberInput
+          this.handleMouseDown(event)
+        }
+      })
+    }
+    this.sensitivityMenu = document.createElement('div')
+    this.sensitivityMenu.className = 'sensitivity-menu' //styles.sensitivityMenu; //"sensitivity-menu";
+    this.container.appendChild(this.sensitivityMenu)
+
+    // create steps
+    const stepsValues = [0.001, 0.01, 0.1, 1, 10, 100]
+    stepsValues.forEach((value) => {
+      const step = document.createElement('div')
+      step.className = 'step' //styles.step //"step";
+      step.dataset.step = value
+      step.textContent = value.toString()
+      this.sensitivityMenu.appendChild(step)
+    })
+
+    this.steps = this.sensitivityMenu.getElementsByClassName('step') //styles.step)
+
+    if (this.debug) {
+      this.debugContainer = document.createElement('div')
+      this.debugContainer.id = 'debug-container' //styles.debugContainer //"debugContainer";
+      document.body.appendChild(this.debugContainer)
+    }
+  }
+  showSensitivityMenu(pageX, pageY) {
+    this.sensitivityMenu.style.display = 'block'
+    this.sensitivityMenu.style.left = `${pageX}px`
+    this.sensitivityMenu.style.top = `${pageY}px`
+    this.initialMouseX = pageX
+    this.lastMouseX = pageX
+    this.isDragging = true
+    this.thresholdExceeded = false
+    this.stepLocked = false
+    this.updateDebugInfo()
+  }
+  updateDebugInfo() {
+    if (this.debug) {
+      this.debugContainer.innerHTML = `
+        <div>Active Step: ${this.activeStep}</div>
+        <div>Initial Mouse X: ${this.initialMouseX}</div>
+        <div>Last Mouse X: ${this.lastMouseX}</div>
+        <div>Accumulated Delta: ${this.accumulatedDelta}</div>
+        <div>Threshold Exceeded: ${this.thresholdExceeded}</div>
+        <div>Step Locked: ${this.stepLocked}</div>
+        <div>Number Input Value: ${this.currentInput?.value}</div>
+    `
+    }
+  }
+  handleMouseDown(event) {
+    if (event.button === 1) {
+      this.showSensitivityMenu(
+        event.target.offsetWidth,
+        event.target.offsetHeight,
+      )
+      event.preventDefault()
+    }
+  }
+  handleMouseUp(event) {
+    if (event.button === 1) {
+      this.resetWidgetState()
+    }
+  }
+  handleClickOutside(event) {
+    if (event.target !== this.numberInput) {
+      this.resetWidgetState()
+    }
+  }
+  handleMouseMove(event) {
+    if (this.sensitivityMenu.style.display === 'block') {
+      const relativeY = event.pageY - 300 // this.sensitivityMenu.offsetTop
+
+      const horizontalDistanceFromInitial = Math.abs(
+        event.target.offsetWidth - this.initialMouseX,
+      )
+
+      // Unlock if the mouse moves back towards the initial position
+      if (horizontalDistanceFromInitial < this.threshold) {
+        this.thresholdExceeded = false
+        this.stepLocked = false
+        this.accumulatedDelta = 0
+      }
+
+      // Update step only if it is not locked
+      if (!this.stepLocked) {
+        for (let step of this.steps) {
+          step.classList.remove('active') //styles.active)
+          step.classList.remove('locked') //styles.locked)
+          if (
+            relativeY >= step.offsetTop &&
+            relativeY <= step.offsetTop + step.offsetHeight
+          ) {
+            step.classList.add('active') //styles.active)
+            this.setActiveStep(parseFloat(step.dataset.step))
+          }
+        }
+      }
+
+      if (this.stepLocked) {
+        this.sensitivityMenu
+          .querySelector('.step.active')
+          ?.classList.add('locked')
+      }
+
+      this.updateStepValue(event.pageX)
+    }
+  }
+
+  initializeEventListeners() {
+    document.addEventListener('mousemove', (event) =>
+      this.handleMouseMove(event),
+    )
+    document.addEventListener('mouseup', (event) => this.handleMouseUp(event))
+
+    document.addEventListener('click', (event) =>
+      this.handleClickOutside(event),
+    )
+  }
+
+  setActiveStep(val) {
+    if (this.activeStep !== val) {
+      this.activeStep = val
+      this.stepLocked = false
+      this.accumulatedDelta = 0
+      this.thresholdExceeded = false
+    }
+  }
+  resetWidgetState() {
+    this.sensitivityMenu.style.display = 'none'
+    this.isDragging = false
+    this.lastMouseX = undefined
+    this.thresholdExceeded = false
+    this.stepLocked = false
+    this.updateDebugInfo()
+  }
+  updateStepValue(mouseX) {
+    if (this.isDragging && this.lastMouseX !== undefined) {
+      const deltaX = mouseX - this.lastMouseX
+      this.accumulatedDelta += deltaX
+
+      if (
+        !this.thresholdExceeded &&
+        Math.abs(this.accumulatedDelta) > this.threshold
+      ) {
+        this.thresholdExceeded = true
+        this.stepLocked = true
+      }
+
+      if (this.thresholdExceeded && this.stepLocked) {
+        // frequency of value changes
+        if (
+          Math.abs(this.accumulatedDelta) * this.mouseSensitivityMultiplier >=
+          1
+        ) {
+          const valueChange = Math.sign(this.accumulatedDelta) * this.activeStep
+          if (this.currentInput) {
+            this.currentInput.value =
+              getValidNumber(this.currentInput) + valueChange
+            this.onChange?.(this.getValue())
+          } else {
+            this.numberInputs.forEach((input) => {
+              input.value = getValidNumber(input) + valueChange
+            })
+          }
+          this.accumulatedDelta = 0
+        }
+      }
+
+      this.lastMouseX = mouseX
+    }
+    this.updateDebugInfo()
+  }
+}
@@ -0,0 +1,8 @@
+ace.define("ace/ext/beautify",["require","exports","module","ace/token_iterator"],function(e,t,n){"use strict";function i(e,t){return e.type.lastIndexOf(t+".xml")>-1}var r=e("../token_iterator").TokenIterator;t.singletonTags=["area","base","br","col","command","embed","hr","html","img","input","keygen","link","meta","param","source","track","wbr"],t.blockTags=["article","aside","blockquote","body","div","dl","fieldset","footer","form","head","header","html","nav","ol","p","script","section","style","table","tbody","tfoot","thead","ul"],t.formatOptions={lineBreaksAfterCommasInCurlyBlock:!0},t.beautify=function(e){var n=new r(e,0,0),s=n.getCurrentToken(),o=e.getTabString(),u=t.singletonTags,a=t.blockTags,f=t.formatOptions||{},l,c=!1,h=!1,p=!1,d="",v="",m="",g=0,y=0,b=0,w=0,E=0,S=0,x=0,T,N=0,C=0,k=[],L=!1,A,O=!1,M=!1,_=!1,D=!1,P={0:0},H=[],B=!1,j=function(){l&&l.value&&l.type!=="string.regexp"&&(l.value=l.value.replace(/^\s*/,""))},F=function(){var e=d.length-1;for(;;){if(e==0)break;if(d[e]!==" ")break;e-=1}d=d.slice(0,e+1)},I=function(){d=d.trimRight(),c=!1};while(s!==null){N=n.getCurrentTokenRow(),k=n.$rowTokens,l=n.stepForward();if(typeof s!="undefined"){v=s.value,E=0,_=m==="style"||e.$modeId==="ace/mode/css",i(s,"tag-open")?(M=!0,l&&(D=a.indexOf(l.value)!==-1),v==="</"&&(D&&!c&&C<1&&C++,_&&(C=1),E=1,D=!1)):i(s,"tag-close")?M=!1:i(s,"comment.start")?D=!0:i(s,"comment.end")&&(D=!1),!M&&!C&&s.type==="paren.rparen"&&s.value.substr(0,1)==="}"&&C++,N!==T&&(C=N,T&&(C-=T));if(C){I();for(;C>0;C--)d+="\n";c=!0,!i(s,"comment")&&!s.type.match(/^(comment|string)$/)&&(v=v.trimLeft())}if(v){s.type==="keyword"&&v.match(/^(if|else|elseif|for|foreach|while|switch)$/)?(H[g]=v,j(),p=!0,v.match(/^(else|elseif)$/)&&d.match(/\}[\s]*$/)&&(I(),h=!0)):s.type==="paren.lparen"?(j(),v.substr(-1)==="{"&&(p=!0,O=!1,M||(C=1)),v.substr(0,1)==="{"&&(h=!0,d.substr(-1)!=="["&&d.trimRight().substr(-1)==="["?(I(),h=!1):d.trimRight().substr(-1)===")"?I():F())):s.type==="paren.rparen"?(E=1,v.substr(0,1)==="}"&&(H[g-1]==="case"&&E++,d.trimRight().substr(-1)==="{"?I():(h=!0,_&&(C+=2))),v.substr(0,1)==="]"&&d.substr(-1)!=="}"&&d.trimRight().substr(-1)==="}"&&(h=!1,w++,I()),v.substr(0,1)===")"&&d.substr(-1)!=="("&&d.trimRight().substr(-1)==="("&&(h=!1,w++,I()),F()):s.type!=="keyword.operator"&&s.type!=="keyword"||!v.match(/^(=|==|===|!=|!==|&&|\|\||and|or|xor|\+=|.=|>|>=|<|<=|=>)$/)?s.type==="punctuation.operator"&&v===";"?(I(),j(),p=!0,_&&C++):s.type==="punctuation.operator"&&v.match(/^(:|,)$/)?(I(),j(),v.match(/^(,)$/)&&x>0&&S===0&&f.lineBreaksAfterCommasInCurlyBlock?C++:(p=!0,c=!1)):s.type==="support.php_tag"&&v==="?>"&&!c?(I(),h=!0):i(s,"attribute-name")&&d.substr(-1).match(/^\s$/)?h=!0:i(s,"attribute-equals")?(F(),j()):i(s,"tag-close")?(F(),v==="/>"&&(h=!0)):s.type==="keyword"&&v.match(/^(case|default)$/)&&B&&(E=1):(I(),j(),h=!0,p=!0);if(c&&(!s.type.match(/^(comment)$/)||!!v.substr(0,1).match(/^[/#]$/))&&(!s.type.match(/^(string)$/)||!!v.substr(0,1).match(/^['"@]$/))){w=b;if(g>y){w++;for(A=g;A>y;A--)P[A]=w}else g<y&&(w=P[g]);y=g,b=w,E&&(w-=E),O&&!S&&(w++,O=!1);for(A=0;A<w;A++)d+=o}s.type==="keyword"&&v.match(/^(case|default)$/)?B===!1&&(H[g]=v,g++,B=!0):s.type==="keyword"&&v.match(/^(break)$/)&&H[g-1]&&H[g-1].match(/^(case|default)$/)&&(g--,B=!1),s.type==="paren.lparen"&&(S+=(v.match(/\(/g)||[]).length,x+=(v.match(/\{/g)||[]).length,g+=v.length),s.type==="keyword"&&v.match(/^(if|else|elseif|for|while)$/)?(O=!0,S=0):!S&&v.trim()&&s.type!=="comment"&&(O=!1);if(s.type==="paren.rparen"){S-=(v.match(/\)/g)||[]).length,x-=(v.match(/\}/g)||[]).length;for(A=0;A<v.length;A++)g--,v.substr(A,1)==="}"&&H[g]==="case"&&g--}s.type=="text"&&(v=v.replace(/\s+$/," ")),h&&!c&&(F(),d.substr(-1)!=="\n"&&(d+=" ")),d+=v,p&&(d+=" "),c=!1,h=!1,p=!1;if(i(s,"tag-close")&&(D||a.indexOf(m)!==-1)||i(s,"doctype")&&v===">")D&&l&&l.value==="</"?C=-1:C=1;l&&u.indexOf(l.value)===-1&&(i(s,"tag-open")&&v==="</"?g--:i(s,"tag-open")&&v==="<"?g++:i(s,"tag-close")&&v==="/>"&&g--),i(s,"tag-name")&&(m=v),T=N}}s=l}d=d.trim(),e.doc.setValue(d)},t.commands=[{name:"beautify",description:"Format selection (Beautify)",exec:function(e){t.beautify(e.session)},bindKey:"Ctrl-Shift-B"}]});                (function() {
+                    ace.require(["ace/ext/beautify"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/code_lens",["require","exports","module","ace/line_widgets","ace/lib/event","ace/lib/lang","ace/lib/dom","ace/editor","ace/config"],function(e,t,n){"use strict";function u(e){var t=e.$textLayer,n=t.$lenses;n&&n.forEach(function(e){e.remove()}),t.$lenses=null}function a(e,t){var n=e&t.CHANGE_LINES||e&t.CHANGE_FULL||e&t.CHANGE_SCROLL||e&t.CHANGE_TEXT;if(!n)return;var r=t.session,i=t.session.lineWidgets,s=t.$textLayer,a=s.$lenses;if(!i){a&&u(t);return}var f=t.$textLayer.$lines.cells,l=t.layerConfig,c=t.$padding;a||(a=s.$lenses=[]);var h=0;for(var p=0;p<f.length;p++){var d=f[p].row,v=i[d],m=v&&v.lenses;if(!m||!m.length)continue;var g=a[h];g||(g=a[h]=o.buildDom(["div",{"class":"ace_codeLens"}],t.container)),g.style.height=l.lineHeight+"px",h++;for(var y=0;y<m.length;y++){var b=g.childNodes[2*y];b||(y!=0&&g.appendChild(o.createTextNode("\u00a0|\u00a0")),b=o.buildDom(["a"],g)),b.textContent=m[y].title,b.lensCommand=m[y]}while(g.childNodes.length>2*y-1)g.lastChild.remove();var w=t.$cursorLayer.getPixelPosition({row:d,column:0},!0).top-l.lineHeight*v.rowsAbove-l.offset;g.style.top=w+"px";var E=t.gutterWidth,S=r.getLine(d).search(/\S|$/);S==-1&&(S=0),E+=S*l.characterWidth,g.style.paddingLeft=c+E+"px"}while(h<a.length)a.pop().remove()}function f(e){if(!e.lineWidgets)return;var t=e.widgetManager;e.lineWidgets.forEach(function(e){e&&e.lenses&&t.removeLineWidget(e)})}function l(e){e.codeLensProviders=[],e.renderer.on("afterRender",a),e.$codeLensClickHandler||(e.$codeLensClickHandler=function(t){var n=t.target.lensCommand;if(!n)return;e.execCommand(n.id,n.arguments),e._emit("codeLensClick",t)},i.addListener(e.container,"click",e.$codeLensClickHandler,e)),e.$updateLenses=function(){function o(){var r=n.selection.cursor,i=n.documentToScreenRow(r),o=n.getScrollTop(),u=t.setLenses(n,s),a=n.$undoManager&&n.$undoManager.$lastDelta;if(a&&a.action=="remove"&&a.lines.length>1)return;var f=n.documentToScreenRow(r),l=e.renderer.layerConfig.lineHeight,c=n.getScrollTop()+(f-i)*l;u==0&&o<l/4&&o>-l/4&&(c=-l),n.setScrollTop(c)}var n=e.session;if(!n)return;n.widgetManager||(n.widgetManager=new r(n),n.widgetManager.attach(e));var i=e.codeLensProviders.length,s=[];e.codeLensProviders.forEach(function(e){e.provideCodeLenses(n,function(e,t){if(e)return;t.forEach(function(e){s.push(e)}),i--,i==0&&o()})})};var n=s.delayedCall(e.$updateLenses);e.$updateLensesOnInput=function(){n.delay(250)},e.on("input",e.$updateLensesOnInput)}function c(e){e.off("input",e.$updateLensesOnInput),e.renderer.off("afterRender",a),e.$codeLensClickHandler&&e.container.removeEventListener("click",e.$codeLensClickHandler)}var r=e("../line_widgets").LineWidgets,i=e("../lib/event"),s=e("../lib/lang"),o=e("../lib/dom");t.setLenses=function(e,t){var n=Number.MAX_VALUE;return f(e),t&&t.forEach(function(t){var r=t.start.row,i=t.start.column,s=e.lineWidgets&&e.lineWidgets[r];if(!s||!s.lenses)s=e.widgetManager.$registerLineWidget({rowCount:1,rowsAbove:1,row:r,column:i,lenses:[]});s.lenses.push(t.command),r<n&&(n=r)}),e._emit("changeFold",{data:{start:{row:n}}}),n},t.registerCodeLensProvider=function(e,t){e.setOption("enableCodeLens",!0),e.codeLensProviders.push(t),e.$updateLensesOnInput()},t.clear=function(e){t.setLenses(e,null)};var h=e("../editor").Editor;e("../config").defineOptions(h.prototype,"editor",{enableCodeLens:{set:function(e){e?l(this):c(this)}}}),o.importCssString("\n.ace_codeLens {\n    position: absolute;\n    color: #aaa;\n    font-size: 88%;\n    background: inherit;\n    width: 100%;\n    display: flex;\n    align-items: flex-end;\n    pointer-events: none;\n}\n.ace_codeLens > a {\n    cursor: pointer;\n    pointer-events: auto;\n}\n.ace_codeLens > a:hover {\n    color: #0000ff;\n    text-decoration: underline;\n}\n.ace_dark > .ace_codeLens > a:hover {\n    color: #4e94ce;\n}\n","codelense.css",!1)});                (function() {
+                    ace.require(["ace/ext/code_lens"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/elastic_tabstops_lite",["require","exports","module","ace/editor","ace/config"],function(e,t,n){"use strict";var r=function(){function e(e){this.$editor=e;var t=this,n=[],r=!1;this.onAfterExec=function(){r=!1,t.processRows(n),n=[]},this.onExec=function(){r=!0},this.onChange=function(e){r&&(n.indexOf(e.start.row)==-1&&n.push(e.start.row),e.end.row!=e.start.row&&n.push(e.end.row))}}return e.prototype.processRows=function(e){this.$inChange=!0;var t=[];for(var n=0,r=e.length;n<r;n++){var i=e[n];if(t.indexOf(i)>-1)continue;var s=this.$findCellWidthsForBlock(i),o=this.$setBlockCellWidthsToMax(s.cellWidths),u=s.firstRow;for(var a=0,f=o.length;a<f;a++){var l=o[a];t.push(u),this.$adjustRow(u,l),u++}}this.$inChange=!1},e.prototype.$findCellWidthsForBlock=function(e){var t=[],n,r=e;while(r>=0){n=this.$cellWidthsForRow(r);if(n.length==0)break;t.unshift(n),r--}var i=r+1;r=e;var s=this.$editor.session.getLength();while(r<s-1){r++,n=this.$cellWidthsForRow(r);if(n.length==0)break;t.push(n)}return{cellWidths:t,firstRow:i}},e.prototype.$cellWidthsForRow=function(e){var t=this.$selectionColumnsForRow(e),n=[-1].concat(this.$tabsForRow(e)),r=n.map(function(e){return 0}).slice(1),i=this.$editor.session.getLine(e);for(var s=0,o=n.length-1;s<o;s++){var u=n[s]+1,a=n[s+1],f=this.$rightmostSelectionInCell(t,a),l=i.substring(u,a);r[s]=Math.max(l.replace(/\s+$/g,"").length,f-u)}return r},e.prototype.$selectionColumnsForRow=function(e){var t=[],n=this.$editor.getCursorPosition();return this.$editor.session.getSelection().isEmpty()&&e==n.row&&t.push(n.column),t},e.prototype.$setBlockCellWidthsToMax=function(e){var t=!0,n,r,i,s=this.$izip_longest(e);for(var o=0,u=s.length;o<u;o++){var a=s[o];if(!a.push){console.error(a);continue}a.push(NaN);for(var f=0,l=a.length;f<l;f++){var c=a[f];t&&(n=f,i=0,t=!1);if(isNaN(c)){r=f;for(var h=n;h<r;h++)e[h][o]=i;t=!0}i=Math.max(i,c)}}return e},e.prototype.$rightmostSelectionInCell=function(e,t){var n=0;if(e.length){var r=[];for(var i=0,s=e.length;i<s;i++)e[i]<=t?r.push(i):r.push(0);n=Math.max.apply(Math,r)}return n},e.prototype.$tabsForRow=function(e){var t=[],n=this.$editor.session.getLine(e),r=/\t/g,i;while((i=r.exec(n))!=null)t.push(i.index);return t},e.prototype.$adjustRow=function(e,t){var n=this.$tabsForRow(e);if(n.length==0)return;var r=0,i=-1,s=this.$izip(t,n);for(var o=0,u=s.length;o<u;o++){var a=s[o][0],f=s[o][1];i+=1+a,f+=r;var l=i-f;if(l==0)continue;var c=this.$editor.session.getLine(e).substr(0,f),h=c.replace(/\s*$/g,""),p=c.length-h.length;l>0&&(this.$editor.session.getDocument().insertInLine({row:e,column:f+1},Array(l+1).join(" ")+"	"),this.$editor.session.getDocument().removeInLine(e,f,f+1),r+=l),l<0&&p>=-l&&(this.$editor.session.getDocument().removeInLine(e,f+l,f),r+=l)}},e.prototype.$izip_longest=function(e){if(!e[0])return[];var t=e[0].length,n=e.length;for(var r=1;r<n;r++){var i=e[r].length;i>t&&(t=i)}var s=[];for(var o=0;o<t;o++){var u=[];for(var r=0;r<n;r++)e[r][o]===""?u.push(NaN):u.push(e[r][o]);s.push(u)}return s},e.prototype.$izip=function(e,t){var n=e.length>=t.length?t.length:e.length,r=[];for(var i=0;i<n;i++){var s=[e[i],t[i]];r.push(s)}return r},e}();t.ElasticTabstopsLite=r;var i=e("../editor").Editor;e("../config").defineOptions(i.prototype,"editor",{useElasticTabstops:{set:function(e){e?(this.elasticTabstops||(this.elasticTabstops=new r(this)),this.commands.on("afterExec",this.elasticTabstops.onAfterExec),this.commands.on("exec",this.elasticTabstops.onExec),this.on("change",this.elasticTabstops.onChange)):this.elasticTabstops&&(this.commands.removeListener("afterExec",this.elasticTabstops.onAfterExec),this.commands.removeListener("exec",this.elasticTabstops.onExec),this.removeListener("change",this.elasticTabstops.onChange))}}})});                (function() {
+                    ace.require(["ace/ext/elastic_tabstops_lite"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+;                (function() {
+                    ace.require(["ace/ext/error_marker"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/hardwrap",["require","exports","module","ace/range","ace/editor","ace/config"],function(e,t,n){"use strict";function i(e,t){function m(e,t,n){if(e.length<t)return;var r=e.slice(0,t),i=e.slice(t),s=/^(?:(\s+)|(\S+)(\s+))/.exec(i),o=/(?:(\s+)|(\s+)(\S+))$/.exec(r),u=0,a=0;o&&!o[2]&&(u=t-o[1].length,a=t),s&&!s[2]&&(u||(u=t),a=t+s[1].length);if(u)return{start:u,end:a};if(o&&o[2]&&o.index>n)return{start:o.index,end:o.index+o[2].length};if(s&&s[2])return u=t+s[2].length,{start:u,end:u+s[3].length}}var n=t.column||e.getOption("printMarginColumn"),i=t.allowMerge!=0,s=Math.min(t.startRow,t.endRow),o=Math.max(t.startRow,t.endRow),u=e.session;while(s<=o){var a=u.getLine(s);if(a.length>n){var f=m(a,n,5);if(f){var l=/^\s*/.exec(a)[0];u.replace(new r(s,f.start,s,f.end),"\n"+l)}o++}else if(i&&/\S/.test(a)&&s!=o){var c=u.getLine(s+1);if(c&&/\S/.test(c)){var h=a.replace(/\s+$/,""),p=c.replace(/^\s+/,""),d=h+" "+p,f=m(d,n,5);if(f&&f.start>h.length||d.length<n){var v=new r(s,h.length,s+1,c.length-p.length);u.replace(v," "),s--,o--}else h.length<a.length&&u.remove(new r(s,h.length,s,a.length))}}s++}}function s(e){if(e.command.name=="insertstring"&&/\S/.test(e.args)){var t=e.editor,n=t.selection.cursor;if(n.column<=t.renderer.$printMarginColumn)return;var r=t.session.$undoManager.$lastDelta;i(t,{startRow:n.row,endRow:n.row,allowMerge:!1}),r!=t.session.$undoManager.$lastDelta&&t.session.markUndoGroup()}}var r=e("../range").Range,o=e("../editor").Editor;e("../config").defineOptions(o.prototype,"editor",{hardWrap:{set:function(e){e?this.commands.on("afterExec",s):this.commands.off("afterExec",s)},value:!1}}),t.hardWrap=i});                (function() {
+                    ace.require(["ace/ext/hardwrap"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/menu_tools/settings_menu.css",["require","exports","module"],function(e,t,n){n.exports="#ace_settingsmenu, #kbshortcutmenu {\n    background-color: #F7F7F7;\n    color: black;\n    box-shadow: -5px 4px 5px rgba(126, 126, 126, 0.55);\n    padding: 1em 0.5em 2em 1em;\n    overflow: auto;\n    position: absolute;\n    margin: 0;\n    bottom: 0;\n    right: 0;\n    top: 0;\n    z-index: 9991;\n    cursor: default;\n}\n\n.ace_dark #ace_settingsmenu, .ace_dark #kbshortcutmenu {\n    box-shadow: -20px 10px 25px rgba(126, 126, 126, 0.25);\n    background-color: rgba(255, 255, 255, 0.6);\n    color: black;\n}\n\n.ace_optionsMenuEntry:hover {\n    background-color: rgba(100, 100, 100, 0.1);\n    transition: all 0.3s\n}\n\n.ace_closeButton {\n    background: rgba(245, 146, 146, 0.5);\n    border: 1px solid #F48A8A;\n    border-radius: 50%;\n    padding: 7px;\n    position: absolute;\n    right: -8px;\n    top: -8px;\n    z-index: 100000;\n}\n.ace_closeButton{\n    background: rgba(245, 146, 146, 0.9);\n}\n.ace_optionsMenuKey {\n    color: darkslateblue;\n    font-weight: bold;\n}\n.ace_optionsMenuCommand {\n    color: darkcyan;\n    font-weight: normal;\n}\n.ace_optionsMenuEntry input, .ace_optionsMenuEntry button {\n    vertical-align: middle;\n}\n\n.ace_optionsMenuEntry button[ace_selected_button=true] {\n    background: #e7e7e7;\n    box-shadow: 1px 0px 2px 0px #adadad inset;\n    border-color: #adadad;\n}\n.ace_optionsMenuEntry button {\n    background: white;\n    border: 1px solid lightgray;\n    margin: 0px;\n}\n.ace_optionsMenuEntry button:hover{\n    background: #f0f0f0;\n}"}),ace.define("ace/ext/menu_tools/overlay_page",["require","exports","module","ace/lib/dom","ace/ext/menu_tools/settings_menu.css"],function(e,t,n){"use strict";var r=e("../../lib/dom"),i=e("./settings_menu.css");r.importCssString(i,"settings_menu.css",!1),n.exports.overlayPage=function(t,n,r){function o(e){e.keyCode===27&&u()}function u(){if(!i)return;document.removeEventListener("keydown",o),i.parentNode.removeChild(i),t&&t.focus(),i=null,r&&r()}function a(e){s=e,e&&(i.style.pointerEvents="none",n.style.pointerEvents="auto")}var i=document.createElement("div"),s=!1;return i.style.cssText="margin: 0; padding: 0; position: fixed; top:0; bottom:0; left:0; right:0;z-index: 9990; "+(t?"background-color: rgba(0, 0, 0, 0.3);":""),i.addEventListener("click",function(e){s||u()}),document.addEventListener("keydown",o),n.addEventListener("click",function(e){e.stopPropagation()}),i.appendChild(n),document.body.appendChild(i),t&&t.blur(),{close:u,setIgnoreFocusOut:a}}}),ace.define("ace/ext/menu_tools/get_editor_keyboard_shortcuts",["require","exports","module","ace/lib/keys"],function(e,t,n){"use strict";var r=e("../../lib/keys");n.exports.getEditorKeybordShortcuts=function(e){var t=r.KEY_MODS,n=[],i={};return e.keyBinding.$handlers.forEach(function(e){var t=e.commandKeyBinding;for(var r in t){var s=r.replace(/(^|-)\w/g,function(e){return e.toUpperCase()}),o=t[r];Array.isArray(o)||(o=[o]),o.forEach(function(e){typeof e!="string"&&(e=e.name),i[e]?i[e].key+="|"+s:(i[e]={key:s,command:e},n.push(i[e]))})}}),n}}),ace.define("ace/ext/keybinding_menu",["require","exports","module","ace/editor","ace/ext/menu_tools/overlay_page","ace/ext/menu_tools/get_editor_keyboard_shortcuts"],function(e,t,n){"use strict";function i(t){if(!document.getElementById("kbshortcutmenu")){var n=e("./menu_tools/overlay_page").overlayPage,r=e("./menu_tools/get_editor_keyboard_shortcuts").getEditorKeybordShortcuts,i=r(t),s=document.createElement("div"),o=i.reduce(function(e,t){return e+'<div class="ace_optionsMenuEntry"><span class="ace_optionsMenuCommand">'+t.command+"</span> : "+'<span class="ace_optionsMenuKey">'+t.key+"</span></div>"},"");s.id="kbshortcutmenu",s.innerHTML="<h1>Keyboard Shortcuts</h1>"+o+"</div>",n(t,s)}}var r=e("../editor").Editor;n.exports.init=function(e){r.prototype.showKeyboardShortcuts=function(){i(this)},e.commands.addCommands([{name:"showKeyboardShortcuts",bindKey:{win:"Ctrl-Alt-h",mac:"Command-Alt-h"},exec:function(e,t){e.showKeyboardShortcuts()}}])}});                (function() {
+                    ace.require(["ace/ext/keybinding_menu"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/linking",["require","exports","module","ace/editor","ace/config"],function(e,t,n){function i(e){var n=e.editor,r=e.getAccelKey();if(r){var n=e.editor,i=e.getDocumentPosition(),s=n.session,o=s.getTokenAt(i.row,i.column);t.previousLinkingHover&&t.previousLinkingHover!=o&&n._emit("linkHoverOut"),n._emit("linkHover",{position:i,token:o}),t.previousLinkingHover=o}else t.previousLinkingHover&&(n._emit("linkHoverOut"),t.previousLinkingHover=!1)}function s(e){var t=e.getAccelKey(),n=e.getButton();if(n==0&&t){var r=e.editor,i=e.getDocumentPosition(),s=r.session,o=s.getTokenAt(i.row,i.column);r._emit("linkClick",{position:i,token:o})}}var r=e("../editor").Editor;e("../config").defineOptions(r.prototype,"editor",{enableLinking:{set:function(e){e?(this.on("click",s),this.on("mousemove",i)):(this.off("click",s),this.off("mousemove",i))},value:!1}}),t.previousLinkingHover=!1});                (function() {
+                    ace.require(["ace/ext/linking"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/modelist",["require","exports","module"],function(e,t,n){"use strict";function i(e){var t=a.text,n=e.split(/[\/\\]/).pop();for(var i=0;i<r.length;i++)if(r[i].supportsFile(n)){t=r[i];break}return t}var r=[],s=function(){function e(e,t,n){this.name=e,this.caption=t,this.mode="ace/mode/"+e,this.extensions=n;var r;/\^/.test(n)?r=n.replace(/\|(\^)?/g,function(e,t){return"$|"+(t?"^":"^.*\\.")})+"$":r="^.*\\.("+n+")$",this.extRe=new RegExp(r,"gi")}return e.prototype.supportsFile=function(e){return e.match(this.extRe)},e}(),o={ABAP:["abap"],ABC:["abc"],ActionScript:["as"],ADA:["ada|adb"],Alda:["alda"],Apache_Conf:["^htaccess|^htgroups|^htpasswd|^conf|htaccess|htgroups|htpasswd"],Apex:["apex|cls|trigger|tgr"],AQL:["aql"],AsciiDoc:["asciidoc|adoc"],ASL:["dsl|asl|asl.json"],Assembly_ARM32:["s"],Assembly_x86:["asm|a"],Astro:["astro"],AutoHotKey:["ahk"],BatchFile:["bat|cmd"],BibTeX:["bib"],C_Cpp:["cpp|c|cc|cxx|h|hh|hpp|ino"],C9Search:["c9search_results"],Cirru:["cirru|cr"],Clojure:["clj|cljs"],Cobol:["CBL|COB"],coffee:["coffee|cf|cson|^Cakefile"],ColdFusion:["cfm|cfc"],Crystal:["cr"],CSharp:["cs"],Csound_Document:["csd"],Csound_Orchestra:["orc"],Csound_Score:["sco"],CSS:["css"],Curly:["curly"],Cuttlefish:["conf"],D:["d|di"],Dart:["dart"],Diff:["diff|patch"],Django:["djt|html.djt|dj.html|djhtml"],Dockerfile:["^Dockerfile"],Dot:["dot"],Drools:["drl"],Edifact:["edi"],Eiffel:["e|ge"],EJS:["ejs"],Elixir:["ex|exs"],Elm:["elm"],Erlang:["erl|hrl"],Flix:["flix"],Forth:["frt|fs|ldr|fth|4th"],Fortran:["f|f90"],FSharp:["fsi|fs|ml|mli|fsx|fsscript"],FSL:["fsl"],FTL:["ftl"],Gcode:["gcode"],Gherkin:["feature"],Gitignore:["^.gitignore"],Glsl:["glsl|frag|vert"],Gobstones:["gbs"],golang:["go"],GraphQLSchema:["gql"],Groovy:["groovy"],HAML:["haml"],Handlebars:["hbs|handlebars|tpl|mustache"],Haskell:["hs"],Haskell_Cabal:["cabal"],haXe:["hx"],Hjson:["hjson"],HTML:["html|htm|xhtml|we|wpy"],HTML_Elixir:["eex|html.eex"],HTML_Ruby:["erb|rhtml|html.erb"],INI:["ini|conf|cfg|prefs"],Io:["io"],Ion:["ion"],Jack:["jack"],Jade:["jade|pug"],Java:["java"],JavaScript:["js|jsm|cjs|mjs"],JEXL:["jexl"],JSON:["json"],JSON5:["json5"],JSONiq:["jq"],JSP:["jsp"],JSSM:["jssm|jssm_state"],JSX:["jsx"],Julia:["jl"],Kotlin:["kt|kts"],LaTeX:["tex|latex|ltx|bib"],Latte:["latte"],LESS:["less"],Liquid:["liquid"],Lisp:["lisp"],LiveScript:["ls"],Log:["log"],LogiQL:["logic|lql"],Logtalk:["lgt"],LSL:["lsl"],Lua:["lua"],LuaPage:["lp"],Lucene:["lucene"],Makefile:["^Makefile|^GNUmakefile|^makefile|^OCamlMakefile|make"],Markdown:["md|markdown"],Mask:["mask"],MATLAB:["matlab"],Maze:["mz"],MediaWiki:["wiki|mediawiki"],MEL:["mel"],MIPS:["s|asm"],MIXAL:["mixal"],MUSHCode:["mc|mush"],MySQL:["mysql"],Nasal:["nas"],Nginx:["nginx|conf"],Nim:["nim"],Nix:["nix"],NSIS:["nsi|nsh"],Nunjucks:["nunjucks|nunjs|nj|njk"],ObjectiveC:["m|mm"],OCaml:["ml|mli"],Odin:["odin"],PartiQL:["partiql|pql"],Pascal:["pas|p"],Perl:["pl|pm"],pgSQL:["pgsql"],PHP:["php|inc|phtml|shtml|php3|php4|php5|phps|phpt|aw|ctp|module"],PHP_Laravel_blade:["blade.php"],Pig:["pig"],PLSQL:["plsql"],Powershell:["ps1"],Praat:["praat|praatscript|psc|proc"],Prisma:["prisma"],Prolog:["plg|prolog"],Properties:["properties"],Protobuf:["proto"],PRQL:["prql"],Puppet:["epp|pp"],Python:["py"],QML:["qml"],R:["r"],Raku:["raku|rakumod|rakutest|p6|pl6|pm6"],Razor:["cshtml|asp"],RDoc:["Rd"],Red:["red|reds"],RHTML:["Rhtml"],Robot:["robot|resource"],RST:["rst"],Ruby:["rb|ru|gemspec|rake|^Guardfile|^Rakefile|^Gemfile"],Rust:["rs"],SaC:["sac"],SASS:["sass"],SCAD:["scad"],Scala:["scala|sbt"],Scheme:["scm|sm|rkt|oak|scheme"],Scrypt:["scrypt"],SCSS:["scss"],SH:["sh|bash|^.bashrc"],SJS:["sjs"],Slim:["slim|skim"],Smarty:["smarty|tpl"],Smithy:["smithy"],snippets:["snippets"],Soy_Template:["soy"],Space:["space"],SPARQL:["rq"],SQL:["sql"],SQLServer:["sqlserver"],Stylus:["styl|stylus"],SVG:["svg"],Swift:["swift"],Tcl:["tcl"],Terraform:["tf","tfvars","terragrunt"],Tex:["tex"],Text:["txt"],Textile:["textile"],Toml:["toml"],TSX:["tsx"],Turtle:["ttl"],Twig:["twig|swig"],Typescript:["ts|mts|cts|typescript|str"],Vala:["vala"],VBScript:["vbs|vb"],Velocity:["vm"],Verilog:["v|vh|sv|svh"],VHDL:["vhd|vhdl"],Visualforce:["vfp|component|page"],Vue:["vue"],Wollok:["wlk|wpgm|wtest"],XML:["xml|rdf|rss|wsdl|xslt|atom|mathml|mml|xul|xbl|xaml"],XQuery:["xq"],YAML:["yaml|yml"],Zeek:["zeek|bro"],Zig:["zig"]},u={ObjectiveC:"Objective-C",CSharp:"C#",golang:"Go",C_Cpp:"C and C++",Csound_Document:"Csound Document",Csound_Orchestra:"Csound",Csound_Score:"Csound Score",coffee:"CoffeeScript",HTML_Ruby:"HTML (Ruby)",HTML_Elixir:"HTML (Elixir)",FTL:"FreeMarker",PHP_Laravel_blade:"PHP (Blade Template)",Perl6:"Perl 6",AutoHotKey:"AutoHotkey / AutoIt"},a={};for(var f in o){var l=o[f],c=(u[f]||f).replace(/_/g," "),h=f.toLowerCase(),p=new s(h,c,l[0]);a[h]=p,r.push(p)}n.exports={getModeForPath:i,modes:r,modesByName:a}});                (function() {
+                    ace.require(["ace/ext/modelist"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/rtl",["require","exports","module","ace/editor","ace/config"],function(e,t,n){"use strict";function s(e,t){var n=t.getSelection().lead;t.session.$bidiHandler.isRtlLine(n.row)&&n.column===0&&(t.session.$bidiHandler.isMoveLeftOperation&&n.row>0?t.getSelection().moveCursorTo(n.row-1,t.session.getLine(n.row-1).length):t.getSelection().isEmpty()?n.column+=1:n.setPosition(n.row,n.column+1))}function o(e){e.editor.session.$bidiHandler.isMoveLeftOperation=/gotoleft|selectleft|backspace|removewordleft/.test(e.command.name)}function u(e,t){var n=t.session;n.$bidiHandler.currentRow=null;if(n.$bidiHandler.isRtlLine(e.start.row)&&e.action==="insert"&&e.lines.length>1)for(var r=e.start.row;r<e.end.row;r++)n.getLine(r+1).charAt(0)!==n.$bidiHandler.RLE&&(n.doc.$lines[r+1]=n.$bidiHandler.RLE+n.getLine(r+1))}function a(e,t){var n=t.session,r=n.$bidiHandler,i=t.$textLayer.$lines.cells,s=t.layerConfig.width-t.layerConfig.padding+"px";i.forEach(function(e){var t=e.element.style;r&&r.isRtlLine(e.row)?(t.direction="rtl",t.textAlign="right",t.width=s):(t.direction="",t.textAlign="",t.width="")})}function f(e){function n(e){var t=e.element.style;t.direction=t.textAlign=t.width=""}var t=e.$textLayer.$lines;t.cells.forEach(n),t.cellCache.forEach(n)}var r=[{name:"leftToRight",bindKey:{win:"Ctrl-Alt-Shift-L",mac:"Command-Alt-Shift-L"},exec:function(e){e.session.$bidiHandler.setRtlDirection(e,!1)},readOnly:!0},{name:"rightToLeft",bindKey:{win:"Ctrl-Alt-Shift-R",mac:"Command-Alt-Shift-R"},exec:function(e){e.session.$bidiHandler.setRtlDirection(e,!0)},readOnly:!0}],i=e("../editor").Editor;e("../config").defineOptions(i.prototype,"editor",{rtlText:{set:function(e){e?(this.on("change",u),this.on("changeSelection",s),this.renderer.on("afterRender",a),this.commands.on("exec",o),this.commands.addCommands(r)):(this.off("change",u),this.off("changeSelection",s),this.renderer.off("afterRender",a),this.commands.off("exec",o),this.commands.removeCommands(r),f(this.renderer)),this.renderer.updateFull()}},rtl:{set:function(e){this.session.$bidiHandler.$isRtl=e,e?(this.setOption("rtlText",!1),this.renderer.on("afterRender",a),this.session.$bidiHandler.seenBidi=!0):(this.renderer.off("afterRender",a),f(this.renderer)),this.renderer.updateFull()}}})});                (function() {
+                    ace.require(["ace/ext/rtl"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/simple_tokenizer",["require","exports","module","ace/tokenizer","ace/layer/text_util"],function(e,t,n){"use strict";function o(e,t){var n=new s(e,new r(t.getRules())),o=[];for(var u=0;u<n.getLength();u++){var a=n.getTokens(u);o.push(a.map(function(e){return{className:i(e.type)?undefined:"ace_"+e.type.replace(/\./g," ace_"),value:e.value}}))}return o}var r=e("../tokenizer").Tokenizer,i=e("../layer/text_util").isTextToken,s=function(){function e(e,t){this._lines=e.split(/\r\n|\r|\n/),this._states=[],this._tokenizer=t}return e.prototype.getTokens=function(e){var t=this._lines[e],n=this._states[e-1],r=this._tokenizer.getLineTokens(t,n);return this._states[e]=r.state,r.tokens},e.prototype.getLength=function(){return this._lines.length},e}();n.exports={tokenize:o}});                (function() {
+                    ace.require(["ace/ext/simple_tokenizer"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/spellcheck",["require","exports","module","ace/lib/event","ace/editor","ace/config"],function(e,t,n){"use strict";var r=e("../lib/event");t.contextMenuHandler=function(e){var t=e.target,n=t.textInput.getElement();if(!t.selection.isEmpty())return;var i=t.getCursorPosition(),s=t.session.getWordRange(i.row,i.column),o=t.session.getTextRange(s);t.session.tokenRe.lastIndex=0;if(!t.session.tokenRe.test(o))return;var u="\x01\x01",a=o+" "+u;n.value=a,n.setSelectionRange(o.length,o.length+1),n.setSelectionRange(0,0),n.setSelectionRange(0,o.length);var f=!1;r.addListener(n,"keydown",function l(){r.removeListener(n,"keydown",l),f=!0}),t.textInput.setInputHandler(function(e){if(e==a)return"";if(e.lastIndexOf(a,0)===0)return e.slice(a.length);if(e.substr(n.selectionEnd)==a)return e.slice(0,-a.length);if(e.slice(-2)==u){var r=e.slice(0,-2);if(r.slice(-1)==" ")return f?r.substring(0,n.selectionEnd):(r=r.slice(0,-1),t.session.replace(s,r),"")}return e})};var i=e("../editor").Editor;e("../config").defineOptions(i.prototype,"editor",{spellcheck:{set:function(e){var n=this.textInput.getElement();n.spellcheck=!!e,e?this.on("nativecontextmenu",t.contextMenuHandler):this.removeListener("nativecontextmenu",t.contextMenuHandler)},value:!0}})});                (function() {
+                    ace.require(["ace/ext/spellcheck"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/split",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/editor","ace/virtual_renderer","ace/edit_session"],function(e,t,n){"use strict";var r=e("./lib/oop"),i=e("./lib/lang"),s=e("./lib/event_emitter").EventEmitter,o=e("./editor").Editor,u=e("./virtual_renderer").VirtualRenderer,a=e("./edit_session").EditSession,f;f=function(e,t,n){this.BELOW=1,this.BESIDE=0,this.$container=e,this.$theme=t,this.$splits=0,this.$editorCSS="",this.$editors=[],this.$orientation=this.BESIDE,this.setSplits(n||1),this.$cEditor=this.$editors[0],this.on("focus",function(e){this.$cEditor=e}.bind(this))},function(){r.implement(this,s),this.$createEditor=function(){var e=document.createElement("div");e.className=this.$editorCSS,e.style.cssText="position: absolute; top:0px; bottom:0px",this.$container.appendChild(e);var t=new o(new u(e,this.$theme));return t.on("focus",function(){this._emit("focus",t)}.bind(this)),this.$editors.push(t),t.setFontSize(this.$fontSize),t},this.setSplits=function(e){var t;if(e<1)throw"The number of splits have to be > 0!";if(e==this.$splits)return;if(e>this.$splits){while(this.$splits<this.$editors.length&&this.$splits<e)t=this.$editors[this.$splits],this.$container.appendChild(t.container),t.setFontSize(this.$fontSize),this.$splits++;while(this.$splits<e)this.$createEditor(),this.$splits++}else while(this.$splits>e)t=this.$editors[this.$splits-1],this.$container.removeChild(t.container),this.$splits--;this.resize()},this.getSplits=function(){return this.$splits},this.getEditor=function(e){return this.$editors[e]},this.getCurrentEditor=function(){return this.$cEditor},this.focus=function(){this.$cEditor.focus()},this.blur=function(){this.$cEditor.blur()},this.setTheme=function(e){this.$editors.forEach(function(t){t.setTheme(e)})},this.setKeyboardHandler=function(e){this.$editors.forEach(function(t){t.setKeyboardHandler(e)})},this.forEach=function(e,t){this.$editors.forEach(e,t)},this.$fontSize="",this.setFontSize=function(e){this.$fontSize=e,this.forEach(function(t){t.setFontSize(e)})},this.$cloneSession=function(e){var t=new a(e.getDocument(),e.getMode()),n=e.getUndoManager();return t.setUndoManager(n),t.setTabSize(e.getTabSize()),t.setUseSoftTabs(e.getUseSoftTabs()),t.setOverwrite(e.getOverwrite()),t.setBreakpoints(e.getBreakpoints()),t.setUseWrapMode(e.getUseWrapMode()),t.setUseWorker(e.getUseWorker()),t.setWrapLimitRange(e.$wrapLimitRange.min,e.$wrapLimitRange.max),t.$foldData=e.$cloneFoldData(),t},this.setSession=function(e,t){var n;t==null?n=this.$cEditor:n=this.$editors[t];var r=this.$editors.some(function(t){return t.session===e});return r&&(e=this.$cloneSession(e)),n.setSession(e),e},this.getOrientation=function(){return this.$orientation},this.setOrientation=function(e){if(this.$orientation==e)return;this.$orientation=e,this.resize()},this.resize=function(){var e=this.$container.clientWidth,t=this.$container.clientHeight,n;if(this.$orientation==this.BESIDE){var r=e/this.$splits;for(var i=0;i<this.$splits;i++)n=this.$editors[i],n.container.style.width=r+"px",n.container.style.top="0px",n.container.style.left=i*r+"px",n.container.style.height=t+"px",n.resize()}else{var s=t/this.$splits;for(var i=0;i<this.$splits;i++)n=this.$editors[i],n.container.style.width=e+"px",n.container.style.top=i*s+"px",n.container.style.left="0px",n.container.style.height=s+"px",n.resize()}}}.call(f.prototype),t.Split=f}),ace.define("ace/ext/split",["require","exports","module","ace/split"],function(e,t,n){"use strict";n.exports=e("../split")});                (function() {
+                    ace.require(["ace/ext/split"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/static-css",["require","exports","module"],function(e,t,n){n.exports=".ace_static_highlight {\n    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'Source Code Pro', 'source-code-pro', 'Droid Sans Mono', monospace;\n    font-size: 12px;\n    white-space: pre-wrap\n}\n\n.ace_static_highlight .ace_gutter {\n    width: 2em;\n    text-align: right;\n    padding: 0 3px 0 0;\n    margin-right: 3px;\n    contain: none;\n}\n\n.ace_static_highlight.ace_show_gutter .ace_line {\n    padding-left: 2.6em;\n}\n\n.ace_static_highlight .ace_line { position: relative; }\n\n.ace_static_highlight .ace_gutter-cell {\n    -moz-user-select: -moz-none;\n    -khtml-user-select: none;\n    -webkit-user-select: none;\n    user-select: none;\n    top: 0;\n    bottom: 0;\n    left: 0;\n    position: absolute;\n}\n\n\n.ace_static_highlight .ace_gutter-cell:before {\n    content: counter(ace_line, decimal);\n    counter-increment: ace_line;\n}\n.ace_static_highlight {\n    counter-reset: ace_line;\n}\n"}),ace.define("ace/ext/static_highlight",["require","exports","module","ace/edit_session","ace/layer/text","ace/ext/static-css","ace/config","ace/lib/dom","ace/lib/lang"],function(e,t,n){"use strict";var r=e("../edit_session").EditSession,i=e("../layer/text").Text,s=e("./static-css"),o=e("../config"),u=e("../lib/dom"),a=e("../lib/lang").escapeHTML,f=function(){function e(e){this.className,this.type=e,this.style={},this.textContent=""}return e.prototype.cloneNode=function(){return this},e.prototype.appendChild=function(e){this.textContent+=e.toString()},e.prototype.toString=function(){var e=[];if(this.type!="fragment"){e.push("<",this.type),this.className&&e.push(" class='",this.className,"'");var t=[];for(var n in this.style)t.push(n,":",this.style[n]);t.length&&e.push(" style='",t.join(""),"'"),e.push(">")}return this.textContent&&e.push(this.textContent),this.type!="fragment"&&e.push("</",this.type,">"),e.join("")},e}(),l={createTextNode:function(e,t){return a(e)},createElement:function(e){return new f(e)},createFragment:function(){return new f("fragment")}},c=function(){this.config={},this.dom=l};c.prototype=i.prototype;var h=function(e,t,n){var r=e.className.match(/lang-(\w+)/),i=t.mode||r&&"ace/mode/"+r[1];if(!i)return!1;var s=t.theme||"ace/theme/textmate",o="",a=[];if(e.firstElementChild){var f=0;for(var l=0;l<e.childNodes.length;l++){var c=e.childNodes[l];c.nodeType==3?(f+=c.data.length,o+=c.data):a.push(f,c)}}else o=e.textContent,t.trim&&(o=o.trim());h.render(o,i,s,t.firstLineNumber,!t.showGutter,function(t){u.importCssString(t.css,"ace_highlight",!0),e.innerHTML=t.html;var r=e.firstChild.firstChild;for(var i=0;i<a.length;i+=2){var s=t.session.doc.indexToPosition(a[i]),o=a[i+1],f=r.children[s.row];f&&f.appendChild(o)}n&&n()})};h.render=function(e,t,n,i,s,u){function c(){var r=h.renderSync(e,t,n,i,s);return u?u(r):r}var a=1,f=r.prototype.$modes;typeof n=="string"&&(a++,o.loadModule(["theme",n],function(e){n=e,--a||c()}));var l;return t&&typeof t=="object"&&!t.getTokenizer&&(l=t,t=l.path),typeof t=="string"&&(a++,o.loadModule(["mode",t],function(e){if(!f[t]||l)f[t]=new e.Mode(l);t=f[t],--a||c()})),--a||c()},h.renderSync=function(e,t,n,i,o){i=parseInt(i||1,10);var u=new r("");u.setUseWorker(!1),u.setMode(t);var a=new c;a.setSession(u),Object.keys(a.$tabStrings).forEach(function(e){if(typeof a.$tabStrings[e]=="string"){var t=l.createFragment();t.textContent=a.$tabStrings[e],a.$tabStrings[e]=t}}),u.setValue(e);var f=u.getLength(),h=l.createElement("div");h.className=n.cssClass;var p=l.createElement("div");p.className="ace_static_highlight"+(o?"":" ace_show_gutter"),p.style["counter-reset"]="ace_line "+(i-1);for(var d=0;d<f;d++){var v=l.createElement("div");v.className="ace_line";if(!o){var m=l.createElement("span");m.className="ace_gutter ace_gutter-cell",m.textContent="",v.appendChild(m)}a.$renderLine(v,d,!1),v.textContent+="\n",p.appendChild(v)}return h.appendChild(p),{css:s+n.cssText,html:h.toString(),session:u}},n.exports=h,n.exports.highlight=h});                (function() {
+                    ace.require(["ace/ext/static_highlight"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/statusbar",["require","exports","module","ace/lib/dom","ace/lib/lang"],function(e,t,n){"use strict";var r=e("../lib/dom"),i=e("../lib/lang"),s=function(){function e(e,t){this.element=r.createElement("div"),this.element.className="ace_status-indicator",this.element.style.cssText="display: inline-block;",t.appendChild(this.element);var n=i.delayedCall(function(){this.updateStatus(e)}.bind(this)).schedule.bind(null,100);e.on("changeStatus",n),e.on("changeSelection",n),e.on("keyboardActivity",n)}return e.prototype.updateStatus=function(e){function n(e,n){e&&t.push(e,n||"|")}var t=[];n(e.keyBinding.getStatusText(e)),e.commands.recording&&n("REC");var r=e.selection,i=r.lead;if(!r.isEmpty()){var s=e.getSelectionRange();n("("+(s.end.row-s.start.row)+":"+(s.end.column-s.start.column)+")"," ")}n(i.row+":"+i.column," "),r.rangeCount&&n("["+r.rangeCount+"]"," "),t.pop(),this.element.textContent=t.join("")},e}();t.StatusBar=s});                (function() {
+                    ace.require(["ace/ext/statusbar"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/themelist",["require","exports","module"],function(e,t,n){"use strict";var r=[["Chrome"],["Clouds"],["Crimson Editor"],["Dawn"],["Dreamweaver"],["Eclipse"],["GitHub"],["IPlastic"],["Solarized Light"],["TextMate"],["Tomorrow"],["XCode"],["Kuroir"],["KatzenMilch"],["SQL Server","sqlserver","light"],["CloudEditor","cloud_editor","light"],["Ambiance","ambiance","dark"],["Chaos","chaos","dark"],["Clouds Midnight","clouds_midnight","dark"],["Dracula","","dark"],["Cobalt","cobalt","dark"],["Gruvbox","gruvbox","dark"],["Green on Black","gob","dark"],["idle Fingers","idle_fingers","dark"],["krTheme","kr_theme","dark"],["Merbivore","merbivore","dark"],["Merbivore Soft","merbivore_soft","dark"],["Mono Industrial","mono_industrial","dark"],["Monokai","monokai","dark"],["Nord Dark","nord_dark","dark"],["One Dark","one_dark","dark"],["Pastel on dark","pastel_on_dark","dark"],["Solarized Dark","solarized_dark","dark"],["Terminal","terminal","dark"],["Tomorrow Night","tomorrow_night","dark"],["Tomorrow Night Blue","tomorrow_night_blue","dark"],["Tomorrow Night Bright","tomorrow_night_bright","dark"],["Tomorrow Night 80s","tomorrow_night_eighties","dark"],["Twilight","twilight","dark"],["Vibrant Ink","vibrant_ink","dark"],["GitHub Dark","github_dark","dark"],["CloudEditor Dark","cloud_editor_dark","dark"]];t.themesByName={},t.themes=r.map(function(e){var n=e[1]||e[0].replace(/ /g,"_").toLowerCase(),r={caption:e[0],theme:"ace/theme/"+n,isDark:e[2]=="dark",name:n};return t.themesByName[n]=r,r})});                (function() {
+                    ace.require(["ace/ext/themelist"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
@@ -0,0 +1,8 @@
+ace.define("ace/ext/whitespace",["require","exports","module","ace/lib/lang"],function(e,t,n){"use strict";var r=e("../lib/lang");t.$detectIndentation=function(e,t){function c(e){var t=0;for(var r=e;r<n.length;r+=e)t+=n[r]||0;return t}var n=[],r=[],i=0,s=0,o=Math.min(e.length,1e3);for(var u=0;u<o;u++){var a=e[u];if(!/^\s*[^*+\-\s]/.test(a))continue;if(a[0]=="	")i++,s=-Number.MAX_VALUE;else{var f=a.match(/^ */)[0].length;if(f&&a[f]!="	"){var l=f-s;l>0&&!(s%l)&&!(f%l)&&(r[l]=(r[l]||0)+1),n[f]=(n[f]||0)+1}s=f}while(u<o&&a[a.length-1]=="\\")a=e[u++]}var h=r.reduce(function(e,t){return e+t},0),p={score:0,length:0},d=0;for(var u=1;u<12;u++){var v=c(u);u==1?(d=v,v=n[1]?.9:.8,n.length||(v=0)):v/=d,r[u]&&(v+=r[u]/h),v>p.score&&(p={score:v,length:u})}if(p.score&&p.score>1.4)var m=p.length;if(i>d+1){if(m==1||d<i/4||p.score<1.8)m=undefined;return{ch:"	",length:m}}if(d>i+1)return{ch:" ",length:m}},t.detectIndentation=function(e){var n=e.getLines(0,1e3),r=t.$detectIndentation(n)||{};return r.ch&&e.setUseSoftTabs(r.ch==" "),r.length&&e.setTabSize(r.length),r},t.trimTrailingSpace=function(e,t){var n=e.getDocument(),r=n.getAllLines(),i=t&&t.trimEmpty?-1:0,s=[],o=-1;t&&t.keepCursorPosition&&(e.selection.rangeCount?e.selection.rangeList.ranges.forEach(function(e,t,n){var r=n[t+1];if(r&&r.cursor.row==e.cursor.row)return;s.push(e.cursor)}):s.push(e.selection.getCursor()),o=0);var u=s[o]&&s[o].row;for(var a=0,f=r.length;a<f;a++){var l=r[a],c=l.search(/\s+$/);a==u&&(c<s[o].column&&c>i&&(c=s[o].column),o++,u=s[o]?s[o].row:-1),c>i&&n.removeInLine(a,c,l.length)}},t.convertIndentation=function(e,t,n){var i=e.getTabString()[0],s=e.getTabSize();n||(n=s),t||(t=i);var o=t=="	"?t:r.stringRepeat(t,n),u=e.doc,a=u.getAllLines(),f={},l={};for(var c=0,h=a.length;c<h;c++){var p=a[c],d=p.match(/^\s*/)[0];if(d){var v=e.$getStringScreenWidth(d)[0],m=Math.floor(v/s),g=v%s,y=f[m]||(f[m]=r.stringRepeat(o,m));y+=l[g]||(l[g]=r.stringRepeat(" ",g)),y!=d&&(u.removeInLine(c,0,d.length),u.insertInLine({row:c,column:0},y))}}e.setTabSize(n),e.setUseSoftTabs(t==" ")},t.$parseStringArg=function(e){var t={};/t/.test(e)?t.ch="	":/s/.test(e)&&(t.ch=" ");var n=e.match(/\d+/);return n&&(t.length=parseInt(n[0],10)),t},t.$parseArg=function(e){return e?typeof e=="string"?t.$parseStringArg(e):typeof e.text=="string"?t.$parseStringArg(e.text):e:{}},t.commands=[{name:"detectIndentation",description:"Detect indentation from content",exec:function(e){t.detectIndentation(e.session)}},{name:"trimTrailingSpace",description:"Trim trailing whitespace",exec:function(e,n){t.trimTrailingSpace(e.session,n)}},{name:"convertIndentation",description:"Convert indentation to ...",exec:function(e,n){var r=t.$parseArg(n);t.convertIndentation(e.session,r.ch,r.length)}},{name:"setIndentation",description:"Set indentation",exec:function(e,n){var r=t.$parseArg(n);r.length&&e.session.setTabSize(r.length),r.ch&&e.session.setUseSoftTabs(r.ch==" ")}}]});                (function() {
+                    ace.require(["ace/ext/whitespace"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mel Massadian	d576190f07	fix: 🐛 category for settings	2024-11-20 21:35:07 +01:00
Mel Massadian	247ad12ec3	fix: 🐛 new UI issues - Fixes the "edit icon cannot be clicked" - Changed the parser to add support for more non std markdown - Markdown links now always open a new tab instead of replacing current - New optional shiki support for code blocks (check #211 for details)	2024-11-18 01:53:04 +01:00
Mel Massadian	881573e2f2	feat: ✨ use the new parser for documentations - might also fix #210	2024-11-18 01:32:29 +01:00
Mel Massadian	6f3a5b5c71	feat: ✨ add @mtb/markdown-parser bundles - the standard one is half the size of showdown - the enhanced one (add shiki with most of its features) is 1.5mb	2024-11-18 00:48:04 +01:00
Mel Massadian	fa017fbb81	chore: 🧹 update externs - remove showdown - update dompurify	2024-11-18 00:45:53 +01:00
Chenlei Hu	dbcca15a21	fix 🐛: input type on MTB_AnyToString (#204 )	2024-10-10 02:13:13 +02:00
Mel Massadian	bc41576fac	docs 📚: fix wiki link closes #202	2024-09-29 00:57:44 +02:00
Mel Massadian	8596b8184e	fix: 🐛 disable old BOOL widget (legacy) This can break if a pack declares a BOOL type fixes #201	2024-09-27 13:33:01 +02:00
Mel Massadian	896a025006	feat: ✨ add VitMatte nodes Basic implementation hardcoded for cuda https://huggingface.co/melmass/pytorch-scripts	2024-09-22 00:16:23 +02:00
Mel Massadian	43092e44a4	fix: 🐛 pass ONNX providers explicitely see #199	2024-09-08 19:58:35 +02:00
bymyself	80b5a0ca74	fix: 🐛 typo in mtb_widgets error catch (#197 )	2024-09-05 14:50:48 +02:00
Mel Massadian	81b3bc1651	fix: 🐛 doc widget sidebar offset in the new ui	2024-08-18 14:26:02 +02:00
Mel Massadian	a825504bdd	chore: 🧹 add pathlibed inputs to utils	2024-08-18 14:07:42 +02:00
Mel Massadian	22190cd25e	chore: 🧹 disable Constant Removing as this doesn't work without my PR	2024-08-16 00:03:25 +02:00
Mel Massadian	a976adbb39	chore: 🧹 new ui is default, flag for old ui	2024-08-16 00:02:18 +02:00
Mel Massadian	997d2fb13a	fix: 🐛 don't fallback to eval addresses legitimate concerns raised in #190 This limits the use a bit, SimpleMath from: https://github.com/cubiq/ComfyUI_essentials Is a better alternative	2024-08-08 22:34:03 +02:00
Mel Massadian	f8829fcb37	chore: 🧹 add methods to shared	2024-08-08 16:57:10 +02:00
Mel Massadian	9651a70341	feat: ✨ add ColorCorrectGPU Alternative to my ColorCorrect using only torch. Also added Mask input for both (optional so this is not a breaking change)	2024-08-01 19:33:13 +02:00
Mel Massadian	57683c3c7d	feat: ✨ add Swap FG/BG colors to MaskToImage	2024-08-01 18:38:58 +02:00
Mel Massadian	f99f92e8f7	feat: ✨ add Extract coordinates wip meant mainly for SAM2	2024-08-01 18:36:12 +02:00
Mel Massadian	5bc125d2f0	docs: 📚 remove link still in issues	2024-08-01 17:32:23 +02:00
Mel Massadian	c99b0812ab	fix: 🐛 rework main utils A whole gymnastic because comfy masks are (B,H,W). maybe unsqueezing first is better but some nodes seems to still output (B,H,W,C), IIRC there is an upstream PR about that	2024-08-01 17:31:18 +02:00
Mel Massadian	333f646ab1	docs: 📚 clean readme	2024-08-01 17:28:33 +02:00
Mel Massadian	dbdf27664c	chore: 🧹 add an old_ui flag to my launcher this is dev related to easily test both UIs see: https://github.com/melMass/CosyVoice-ComfyUI/commit/29510c36f0f8c1e4e5209148d14fe038947728c1	2024-07-31 04:59:36 +02:00
Mel Massadian	7d5569e5c1	chore: 🧹 move qrcode to his own file Each files in `./nodes` can fail, but this means all nodes in the file are skipped... `Generate` has "too important" nodes to fail and doesn't require any extra dependencies. This change allow qrcode to fail on its own	2024-07-31 04:59:17 +02:00
Mel Massadian	5681b464ad	feat: ✨ add AudioCut and make AudioSequence able to get negative "silence" which would effectively "overlap" the joining sections	2024-07-31 04:42:40 +02:00
Mel Massadian	8d0fcee2f3	feat: ✨ add AudioStack To stack/overlay audios.	2024-07-28 20:11:31 +02:00
Mel Massadian	1078fc6f0f	feat: ✨ add AudioSequence node	2024-07-28 17:20:01 +02:00
Mel Massadian	821a0ef427	fix: 🐛 MaskToImage also remove style debug	2024-07-07 20:40:18 +02:00
Mel Massadian	9007a70aa0	feat: ✨ add Split Bbox node	2024-07-06 18:30:14 +02:00
Mel Massadian	1a0ebd5173	feat: ✨ update lerp example	2024-07-06 18:26:45 +02:00
Mel Massadian	59608320c8	⬆️ Bump version: 0.1.5 → 0.1.6	2024-07-03 18:16:37 +02:00
Mel Massadian	d64fac4b74	fix: 🐛 menu callback issue `+` on arrays returns a string in js...	2024-07-03 18:11:07 +02:00
Mel Massadian	d687497d80	chore: 🧹 better classname extraction Allow for consecutive uppercase letters: - MTB_BatchFromHistoryV2 -> Batch From History V2 - MTB_CLIPInterpolate -> CLIP Interpolate	2024-07-03 16:00:48 +02:00
Mel Massadian	d6343e1860	feat: ✨ add alpha channel support for faceswap/restore Fixes #187	2024-07-03 15:59:09 +02:00
Mel Massadian	4eebdd8b8b	ci: 🤖 limit release only to tags I regularly need to push to main without needing to update the extension's code / registry.	2024-07-02 13:14:00 +02:00
Mel Massadian	372e035686	Merge branch 'main' of https://github.com/melMass/comfy_mtb	2024-07-02 13:09:05 +02:00
Mel Massadian	fb34671ee6	chore: 🧹 runner	2024-07-02 13:08:57 +02:00
Elthariel	f25f6bdcd1	docs: 📚 Update requirements file in INSTALL.md (#186 )	2024-06-26 15:05:45 +02:00
Mel Massadian	f1b484617a	ci: 🤖 only publish on tag I can still autotag easily but it avoids bumping too much versions to quickly	2024-06-22 20:17:14 +02:00
Mel Massadian	4507842a70	chore: 🧹 small fixes - Handle image dimension mismatch in ConcatImages (Error,Smallest,Largest) - typing	2024-06-22 20:13:59 +02:00
Mel Massadian	e10faab458	⬆️ Bump version: 0.1.4 → 0.1.5	2024-06-21 20:54:30 +02:00
Mel Massadian	bb5682aa6d	chore: 🧹 add fields for the registry	2024-06-21 20:48:55 +02:00
Mel Massadian	59612fd811	chore: 🧹 add pre-commit	2024-06-21 20:44:46 +02:00
Mel Massadian	30eb5b0091	chore 🧹: prepare for auto versioning	2024-06-21 19:55:50 +02:00
Mel Massadian	1edc2cd10d	fix: 🐛 keep the last model match instead of first See #184 for details	2024-06-21 19:53:25 +02:00
Mel Massadian	fa3199be2b	docs: 📚 update the wiki	2024-06-09 19:19:55 +02:00
Mel Massadian	43d65ae68c	feat: ✨ add ModelPruner (wip)	2024-06-09 19:13:46 +02:00
Mel Massadian	dfd17f6d78	chore: 🧹 migrate from poetry to setuptools	2024-06-09 15:23:07 +02:00
Mel Massadian	1070edd024	chore: 🧹 remove logs	2024-05-27 22:28:53 +02:00
Mel Massadian	9f0ed85cc1	Merge branch 'main' of https://github.com/melMass/comfy_mtb	2024-05-27 22:25:45 +02:00
Mel Massadian	35622e3a5e	fix: 🐛 properly initialize the curve value Also restored the old sorting logic adapted for Object Closes #183 note: the ux is still bad and will improve	2024-05-27 22:25:28 +02:00
Mel Massadian	644371e5b5	chore: 🧹 add more pyproject meta	2024-05-21 12:51:40 +02:00
Mel Massadian	f3d468cfc2	ci: 🤖 move at the proper location	2024-05-21 12:45:22 +02:00
haohaocreatesandMel Massadian	6cd448b026	ci: 🤖 add CI to publish to ComfyUI Registry (#182 ) * publish-action * feat ⚡: rename token and add icons --------- Co-authored-by: Mel Massadian <melmassadian@gmail.com>	2024-05-21 12:40:16 +02:00
haohaocreatesandMel Massadian	5951c90b10	chore: 🧹 add ComfyUI registry to pyproject.toml (#181 ) * Add pyproject.toml for Custom Node Registry * feat ⚡: add publisher id --------- Co-authored-by: Mel Massadian <melmassadian@gmail.com>	2024-05-21 12:37:54 +02:00
bymyself	6abac2e470	feat: ✨ Use dynamic contrast in Color Correct (#180 ) * Change contrast_adjustment_tensor method to change contrast dynamically * Switch to Adobe RGB color space	2024-05-20 23:32:15 +02:00
Mel Massadian	01c73e1c5e	feat ⚡: add more options to load image sequence	2024-05-17 17:35:53 +02:00
Mel Massadian	5060c56135	feat: ✨ StackImages add support for batch mismatch Useful for comparing a static image with a batch of images for instance.	2024-05-15 12:21:10 +02:00
bymyselfandMel Massadian	acc2d687d5	fix: 🐛 ImageCompare improvements (#176 ) * avoid unnecessary numpy conversion for diff and blend * add support for Batch * add support for input mismatch (RGB/RGBA) * fixes #175 --------- Co-authored-by: Mel Massadian <mel@melmassadian.com>	2024-05-14 21:16:56 +02:00
vxkj1211andMel Massadian	780c52f03a	fix: 🐛 repetitive warning (#177 ) Co-authored-by: Mel Massadian <mel@melmassadian.com>	2024-05-14 16:09:10 +02:00
Mel Massadian	2fe0859476	docs 📚: update wiki	2024-05-14 15:36:43 +02:00
Mel Massadian	1186239751	chore 🧹: use sections properly	2024-05-14 15:36:29 +02:00
Mel Massadian	96a0da9dbd	chore: 🧹 update types	2024-05-10 20:30:46 +02:00
Mel Massadian	f9d2ebf91d	feat: ✨ add BatchFloatMath Simple math operations on FLOATS (list of floats)	2024-05-07 23:42:02 +02:00
Mel Massadian	1b7ae27cc1	feat: ✨ add FLOATS to INTS For using it with FrameInterpolation's new multiplier	2024-05-07 19:22:23 +02:00
Mel Massadian	e312b02ad2	wip: 🚧 curve widget logic fixed Most of the logic is fixed, but it still needs some UI/UX tweaks.	2024-05-07 18:40:12 +02:00
Mel Massadian	63ee25d001	feat: ✨ debug dict it was only working on conditions	2024-05-07 18:36:56 +02:00
Mel Massadian	1caf7c18c3	feat: ✨ add Swap BG/FG color menu item	2024-05-07 08:29:57 +02:00
Mel Massadian	349a8524c6	fix: 🐛 add back was conversion node To avoid breaking other worklfows I thought this was now builtin WAS suite. Fixes #172	2024-05-02 07:58:37 +02:00
Mel Massadian	15330eab65	fix: 🐛 drag lag on documentation resize handle	2024-04-28 16:54:42 +02:00
Mel Massadian	1571782d01	fix: 🐛 kwarg typo floats vs float	2024-04-28 15:51:24 +02:00
Mel Massadian	5b4030288d	fix: 🐛 seed of PlotBatchFloat Also using random colors instead of mapped to colormap, the values weren't distinct enough	2024-04-28 15:18:27 +02:00
Mel Massadian	ab58c36212	feat: ✨ BatchFloatFit the batch version of FitNumber	2024-04-28 15:18:27 +02:00
Mel Massadian	5a0ef0dadd	fix: 🐛 forceInput for FLOAT <-> FLOATS converters	2024-04-28 13:10:36 +02:00
Mel Massadian	967e72fc66	fix: 🐛 FLOAT always need options to be set Fixes #171	2024-04-28 13:04:38 +02:00
Mel Massadian	78a86daaf7	feat: ✨ add FloatToFloats (the counterpart)	2024-04-27 21:11:53 +02:00
Mel Massadian	bee3f47a14	fix: 🐛 remove doc if opened on node delete	2024-04-27 20:25:54 +02:00
Mel Massadian	2159395389	feat: ✨ add some FLOATS batch nodes * TimeWrap * Normalize	2024-04-27 19:47:45 +02:00
Mel Massadian	b11346aba8	fix: 🐛 for documentation on HiDPI thanks @kijai	2024-04-27 19:46:25 +02:00
Mel Massadian	30982fa488	fix: 🐛 never remove input 0 of dynamic inputs If you reloaded a graph containing a node with dynamic inputs but none connected the node would end up input-less	2024-04-27 16:29:34 +02:00
Mel Massadian	92b79906cd	fix: 🐛 use the same fix as dynamicInputs for debug i.e we don't auto delete inputs on disconnect, only on connect of inputs	2024-04-27 14:58:50 +02:00
Mel Massadian	76f365b5ee	fix: 🐛 missing numberInput This is the first iteration of the "multi" number inputs. The behaviour is based on Houdini number inputs	2024-04-27 14:16:07 +02:00
Mel Massadian	da67e766c2	fix: 🐛 better curve	2024-04-27 04:08:09 +02:00
Mel Massadian	49cea8d945	docs: 📚 update wiki submodule	2024-04-27 01:17:25 +02:00
Mel Massadian	b1d74adb15	fix: 🐛 prepend MTB_ to all classes to avoid any future clash.	2024-04-27 01:13:32 +02:00
Mel Massadian	652ac3f3b9	fix: 🐛 dynamic connections	2024-04-26 21:11:32 +02:00
Mel Massadian	060e733605	Merge branch 'main' into fix/js-refactor	2024-04-25 22:19:28 +02:00
Mel Massadian	eedbb4bc65	wip: 🚧 dump3	2024-04-25 22:08:25 +02:00
Mel Massadian	fa2397585f	wip: 🚧 dump	2024-04-25 21:56:59 +02:00
Mel Massadian	77348c4adb	Merge branch 'main' into fix/js-refactor	2024-04-25 21:42:12 +02:00
Mel Massadian	0d0fb8e13a	wip: 🚧 dump js refactor start	2024-04-25 21:41:40 +02:00
Mel Massadian	eb48b7a277	Merge branch 'main' into dev/doc-widget	2024-04-25 20:57:01 +02:00
Mel Massadian	dff5b2201d	feat: ✨ add the backend node for Constant This requires this PR to be merged: https://github.com/comfyanonymous/ComfyUI/pull/3329 There is a trick to make it work without that PR but it feels very hacky, the code for it is kept for reference but unused	2024-04-25 20:56:16 +02:00
Mel Massadian	100067a645	fix: 🐛 remaining issue before merge	2024-04-25 20:42:34 +02:00
Mel Massadian	5998924926	docs: 📚 add the wiki as a submodule	2024-04-25 03:21:49 +02:00
Mel Massadian	c19aa007e6	Merge branch 'main' into dev/doc-widget	2024-04-25 02:27:29 +02:00
Mel Massadian	cbb5dd2cf8	feat: ✨ add Constant node For now supports: - number (int/float) - string - vector (2, 3, 4) - color (serialised as HEX)	2024-04-21 17:12:13 +02:00
Mel Massadian	64cc4e9649	chore: 🧹 cleanup js	2024-04-21 17:03:58 +02:00
Mel Massadian	7807449e6d	fix: 🐛 debug issues also properly print to console now...	2024-04-21 17:01:25 +02:00
Mel Massadian	e838c04758	fix: 🐛 errors when insightface's folder missing This would polute output	2024-04-18 14:38:29 +02:00
Mel Massadian	e40ad7a574	fix: 🐛 typo	2024-04-18 14:37:22 +02:00
Mel Massadian	6ebecfd8cf	feat: ✨ add FloatsToFloat I just discovered how most commonly used extensions where dealing with list of values... they mistype it. Not sure the reason this was "standardized", probably to mimic image batches? This node makes mtb FLOATS work with these.	2024-04-18 13:52:42 +02:00
Mel Massadian	1da483a8ba	fix: 🐛 better defaults (cont) :)	2024-04-08 21:33:19 +02:00
Mel Massadian	5eff38b387	fix: 🐛 better defaults for Autopan	2024-04-08 21:30:58 +02:00
Mel Massadian	35139371e8	feat: ✨ add AutoPanEquilateral	2024-04-08 15:54:14 +02:00
Mel Massadian	9ab20a0ab5	fix: 🐛 dynamic inputs Not making them sequential introduces strange bugs	2024-04-07 00:33:39 +02:00
Mel Massadian	5db3ebedb9	feat: ✨ add MatchDimensions simplifies mismatching tensors for comparaisons	2024-04-07 00:32:36 +02:00
Mel Massadian	8d65556c37	feat: ✨ add equilateral example	2024-04-06 20:54:40 +02:00
Mel Massadian	ba73fc6af7	feat: ✨ enhance tiling tools - Add a separate X & Y seamless model patch - Add a separate X & Y tile offset check This theorically allow to generate proper equilateral env	2024-04-06 20:06:48 +02:00
Mel Massadian	92c810c503	feat: ✨ add FLOATS support to blur	2024-04-02 21:56:52 +02:00
Mel Massadian	7c3558273b	fix: 🐛 bundle ace editor Bundles the Ace editor from ace-builds ref build commit: https://github.com/ajaxorg/ace-builds/tree/a6c99a08252c1e6f0dfb61c29bc20b79d9324143 closes #166 and #167	2024-04-02 17:23:49 +02:00
Mel Massadian	c9836a87f6	docs: 📚 missing doc	2024-04-02 17:18:26 +02:00
Mel Massadian	f658fc31e0	feat: ✨ add "tube" to Batch Shape	2024-04-02 05:34:34 +02:00
Mel Massadian	f16d576f6f	fix: 🐛 image to mask	2024-04-02 05:33:16 +02:00
Mel Massadian	e56508c207	fix: 🐛 prepend MTB to classnames Avoid clashing with other extensions/core nodes.	2024-04-01 21:17:26 +02:00
Mel Massadian	edd7c3f5d0	chore: 🧹 add savedatabundle js part wip	2024-04-01 14:09:21 +02:00
Mel Massadian	71bfdd61d7	chore: 🧹 wip dynamic multitype This just allow to pass a list of types to dynamic widgets. Not used yet. The idea is to use "*" but then limit it to the given types. Used in SaveDataBundle	2024-04-01 13:59:20 +02:00
Mel Massadian	9a4b27d2e0	fix: 🐛 allow smaller values in BatchTransform Using a smaller step to avoid 0 division on low values. Also added some typing	2024-04-01 13:57:01 +02:00
Mel Massadian	eeac8c002a	fix: 🐛 add category for virtual note+ Should fix: https://github.com/Nuked88/ComfyUI-N-Sidebar/issues/19	2024-03-28 20:17:02 +01:00
Mel Massadian	991af4f45f	docs: 📚 use flat icon	2024-03-25 01:01:14 +01:00
Mel Massadian	9ce34b47fd	docs: 📚 add banodoco channel link	2024-03-25 00:57:10 +01:00
Mel Massadian	df0a98b94a	fix: 🐛 make image feed of by default Still here, just reverting the default. Local Storage on some context isn't perserved so I will use some fallback but in the meantime this is better off.	2024-03-23 22:04:05 +01:00
Mel Massadian	a344cdcba9	chore: 🧹 use a gettattr fallback to avoid B009 auto reformatting...	2024-03-22 08:04:01 +01:00
Mel Massadian	68184552dd	Merge branch 'main' into dev/doc-widget	2024-03-22 07:59:28 +01:00
Mel Massadian	fac7529d1f	feat: ✨ poc of the doc widget idea	2024-03-22 06:35:16 +01:00