⬆️ Bump version: 0.1.5 → 0.1.6

`+` on arrays returns a string in js...

.editorconfig

@@ -0,0 +1,2 @@
+[*]
+end_of_line = lf

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -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:

.github/workflows/publish_action.yml

@@ -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 }}

.gitmodules

@@ -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

.nvim.lua

@@ -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

.pre-commit-config.yaml

@@ -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

INSTALL.md

@@ -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>

README.md

@@ -15,6 +15,11 @@
 
 [**Install Guide**](./INSTALL.md) | [**Examples**](https://github.com/melMass/comfy_mtb/wiki/Examples)
 
+There is now a dedicated `#mtb-nodes` channel on the Banodoco discord:  
+[![](https://dcbadge.vercel.app/api/server/AXhsabmDhn?style=flat)](https://discord.gg/IAXhsabmDhn)
+
+---
+
 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).
@@ -41,6 +46,7 @@ mtb add a few widgets like `COLOR`
 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" />
 
+<!-- NOTE: Here it should just be some examples and warnings, move the rest to the wiki -->
 
 # Node List
 

__init__.py

@@ -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),

biome.json

@@ -0,0 +1,22 @@
+{
+    "$schema": "https://biomejs.dev/schemas/1.6.1/schema.json",
+    "organizeImports": {
+        "enabled": true
+    },
+    "linter": {
+        "enabled": true,
+        "rules": {
+            "recommended": true
+        }
+    },
+    "formatter": {
+        "lineEnding": "lf"
+    },
+    "javascript": {
+        "formatter": {
+            "quoteStyle": "single",
+            "semicolons": "asNeeded",
+            "indentWidth": 2
+        }
+    }
+}

endpoint.py

@@ -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:

env.nu

@@ -0,0 +1,158 @@
+# NOTE: This file is only use for development you can ignore it
+
+use path.nu *
+
+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, --listen] {
+    let root = get_root --clean=($clean)
+    cd $root
+    MTB_DEBUG=true python main.py --port 3000 --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 .
+}
+
+
+
+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
+}
+
+

log.py

@@ -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()

nodes/animation.py

@@ -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]

nodes/batch.py

@@ -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,
 ]

nodes/conditions.py

@@ -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,13 +166,15 @@ 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]}")
@@ -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]

nodes/constant.py

@@ -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]

nodes/crop.py

@@ -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,11 @@ 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_BboxFromMask:
     """From a mask extract the bounding box"""
 
     @classmethod
@@ -62,7 +67,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 +110,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 +125,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 +151,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 +171,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 +218,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 +247,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 +278,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 +306,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 +324,4 @@ class Uncrop:
         return (pil2tensor(out_images),)
 
 
-__nodes__ = [BboxFromMask, Bbox, Crop, Uncrop]
+__nodes__ = [MTB_BboxFromMask, MTB_Bbox, MTB_Crop, MTB_Uncrop]

nodes/curve.py

@@ -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]

nodes/debug.py

@@ -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]

nodes/deep_bump.py

@@ -303,7 +303,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 +386,4 @@ class DeepBump:
         return (torch.cat(out_images, dim=0),)
 
 
-__nodes__ = [DeepBump]
+__nodes__ = [MTB_DeepBump]

nodes/faceenhance.py

@@ -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]

nodes/faceswap.py

@@ -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]

nodes/generate.py

@@ -52,7 +52,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,7 +113,7 @@ class UnsplashImage:
             return (None,)
 
 
-class QrCode:
+class MTB_QrCode:
     """Basic QR Code generator"""
 
     @classmethod
@@ -193,13 +193,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 +229,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 +364,8 @@ class TextToImage:
 
 
 __nodes__ = [
-    QrCode,
-    UnsplashImage,
-    TextToImage,
+    MTB_QrCode,
+    MTB_UnsplashImage,
+    MTB_TextToImage,
     #  MtbExamples,
 ]

nodes/graph_utils.py

@@ -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,7 +411,7 @@ class GetBatchFromHistory:
         return pil2tensor(frames)
 
 
-class AnyToString:
+class MTB_AnyToString:
     """Tries to take any input and convert it to a string."""
 
     @classmethod
@@ -218,7 +446,7 @@ class AnyToString:
             return (str(input),)
 
 
-class StringReplace:
+class MTB_StringReplace:
     """Basic string replacement."""
 
     @classmethod
@@ -267,7 +495,6 @@ class MTB_MathExpression:
     )
 
     def eval_expression(self, expression, **kwargs):
-        import math
         from ast import literal_eval
 
         for key, value in kwargs.items():
@@ -295,7 +522,7 @@ class MTB_MathExpression:
         return (result, int(result))
 
 
-class FitNumber:
+class MTB_FitNumber:
     """Fit the input float using a source and target range"""
 
     @classmethod
@@ -304,35 +531,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 +584,7 @@ class FitNumber:
         return (res,)
 
 
-class ConcatImages:
+class MTB_ConcatImages:
     """Add images to batch."""
 
     RETURN_TYPES = ("IMAGE",)
@@ -379,29 +595,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,
 ]

nodes/image_interpolation.py

@@ -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]

nodes/image_processing.py

@@ -13,7 +13,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, tensor2np, tensor2pil
 
 # try:
 #     from cv2.ximgproc import guidedFilter
@@ -35,7 +35,7 @@ def gaussian_kernel(
     return g / g.sum()
 
 
-class ColorCorrect:
+class MTB_ColorCorrect:
     """Various color correction methods"""
 
     @classmethod
@@ -86,7 +86,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
@@ -195,7 +202,7 @@ class ColorCorrect:
         return (image,)
 
 
-class ImageCompare_:
+class MTB_ImageCompare:
     """Compare two images and return a difference image"""
 
     @classmethod
@@ -216,22 +223,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 +304,7 @@ class LoadImageFromUrl_:
         return (pil2tensor(image),)
 
 
-class Blur_:
+class MTB_Blur:
     """Blur an image using a Gaussian filter."""
 
     @classmethod
@@ -268,28 +314,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 +465,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
@@ -412,7 +485,7 @@ class MaskToImage:
     FUNCTION = "render_mask"
 
     def render_mask(self, mask, color, background):
-        masks = tensor2np(mask)
+        masks = tensor2np(mask)[0]
         images = []
         for m in masks:
             _mask = Image.fromarray(m).convert("L")
@@ -436,10 +509,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:
@@ -499,24 +569,31 @@ class ColoredImage:
         color,
         width,
         height,
-        foreground_image: Optional[torch.Tensor] = None,
-        foreground_mask: Optional[torch.Tensor] = None,
+        foreground_image: torch.Tensor | None = None,
+        foreground_mask: torch.Tensor | None = 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
+            fg_masks = [None] * foreground_image.size()[0]
 
             if foreground_mask is not None:
+                fg_size = foreground_image.size()[0]
+                mask_size = foreground_mask.size()[0]
+
+                if fg_size == 1 and mask_size > fg_size:
+                    foreground_image = foreground_image.repeat(
+                        mask_size, 1, 1, 1
+                    )
+
                 if foreground_image.size()[0] != foreground_mask.size()[0]:
                     raise ValueError(
                         "Foreground image and mask must have same batch size"
                     )
                 fg_masks = tensor2pil(foreground_mask.unsqueeze(-1))
 
+            fg_images = tensor2pil(foreground_image)
+
             for fg_image, fg_mask in zip(fg_images, fg_masks):
                 # Resize and crop if dimensions mismatch
                 if fg_image.size != image.size:
@@ -552,7 +629,7 @@ class ColoredImage:
         return (output,)
 
 
-class ImagePremultiply:
+class MTB_ImagePremultiply:
     """Premultiply image with mask"""
 
     @classmethod
@@ -591,7 +668,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 +762,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 +871,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 +879,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 +890,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 +910,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 +923,16 @@ class ImageTileOffset:
 
 
 __nodes__ = [
-    ColorCorrect,
-    ImageCompare_,
-    ImageTileOffset,
-    Blur_,
+    MTB_ColorCorrect,
+    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,
 ]

nodes/image_utils.py

@@ -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]

nodes/io.py

@@ -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,
+]

nodes/latent_processing.py

@@ -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,
 ]

nodes/mask.py

@@ -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,
 ]

nodes/model.py

@@ -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]

nodes/number.py

@@ -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,
 ]

nodes/prune.py

@@ -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]

nodes/transform.py

@@ -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]

nodes/video.py

@@ -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,
 ]

pyproject.toml

@@ -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

types/shared.d.ts

@@ -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
+}

types/typedefs.js

@@ -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
+ */
+

utils.py

@@ -1,5 +1,6 @@
 import contextlib
 import functools
+import importlib
 import math
 import os
 import shlex
@@ -8,8 +9,9 @@ import socket
 import subprocess
 import sys
 import uuid
+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
@@ -43,6 +45,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 +210,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 +425,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)
 
@@ -257,6 +472,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 +481,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,7 +501,7 @@ PIL_FILTER_MAP = {
 
 
 # region TENSOR Utilities
-def tensor2pil(image: torch.Tensor) -> List[Image.Image]:
+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 = []
@@ -294,7 +518,7 @@ def tensor2pil(image: torch.Tensor) -> List[Image.Image]:
     ]
 
 
-def pil2tensor(image: Union[Image.Image, List[Image.Image]]) -> torch.Tensor:
+def pil2tensor(image: Image.Image | list[Image.Image]) -> torch.Tensor:
     if isinstance(image, list):
         return torch.cat([pil2tensor(img) for img in image], dim=0)
 
@@ -303,14 +527,16 @@ def pil2tensor(image: Union[Image.Image, List[Image.Image]]) -> torch.Tensor:
     ).unsqueeze(0)
 
 
-def np2tensor(img_np: Union[np.ndarray, List[np.ndarray]]) -> torch.Tensor:
+def np2tensor(
+    img_np: np.ndarray | list[np.ndarray[np.float32]],
+) -> torch.Tensor:
     if isinstance(img_np, list):
         return torch.cat([np2tensor(img) for img in img_np], dim=0)
 
     return torch.from_numpy(img_np.astype(np.float32) / 255.0).unsqueeze(0)
 
 
-def tensor2np(tensor: torch.Tensor) -> List[np.ndarray]:
+def tensor2np(tensor: torch.Tensor) -> list[np.ndarray[np.float32]]:
     batch_count = tensor.size(0) if len(tensor.shape) > 3 else 1
     if batch_count > 1:
         out = []
@@ -572,10 +798,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 +836,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

web/constant.js

@@ -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)'
+  // },
+})

web/curve_widget.js

@@ -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,
         }
-    },
-
+      },
+    }
+  },
 })

web/debug.js

@@ -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

web/imageFeed.js

@@ -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)
 

web/mtb_widgets.js

@@ -7,6 +7,8 @@
  *
  */
 
+/// <reference path="../types/typedefs.js" />
+
 // TODO: Use the builtin addDOMWidget everywhere appropriate
 
 import { app } from '../../scripts/app.js'
@@ -14,10 +16,11 @@ import { api } from '../../scripts/api.js'
 
 import parseCss from './extern/parse-css.js'
 import * as shared from './comfy_shared.js'
-import { log } from './comfy_shared.js'
+import { infoLogger } from './comfy_shared.js'
+import { NumberInputWidget } from './numberInput.js'
 
 // NOTE: new widget types registered by MTB Widgets
-const newTypes = [, /*'BOOL'*/ 'COLOR', 'BBOX']
+const newTypes = [/*'BOOL'*/ , 'COLOR', 'BBOX']
 
 const deprecated_nodes = {
   //  'Animation Builder':
@@ -54,7 +57,250 @@ const calculateTextDimensions = (ctx, value, width, fontSize = 16) => {
   return { textHeight, maxLineWidth }
 }
 
+export function addMultilineWidget(node, name, opts, callback) {
+  const inputEl = document.createElement('textarea')
+  inputEl.className = 'comfy-multiline-input'
+  inputEl.value = opts.defaultVal
+  inputEl.placeholder = opts.placeholder || name
+
+  const widget = node.addDOMWidget(name, 'textmultiline', inputEl, {
+    getValue() {
+      return inputEl.value
+    },
+    setValue(v) {
+      inputEl.value = v
+    },
+  })
+  widget.inputEl = inputEl
+
+  inputEl.addEventListener('input', () => {
+    callback?.(widget.value)
+    widget.callback?.(widget.value)
+  })
+  widget.onRemove = () => {
+    inputEl.remove()
+  }
+
+  return { minWidth: 400, minHeight: 200, widget }
+}
+
+export const VECTOR_AXIS = {
+  0: 'x',
+  1: 'y',
+  2: 'z',
+  3: 'w',
+}
+
+export function addVectorWidgetW(
+  node,
+  name,
+  value,
+  vector_size,
+  callback,
+  app,
+) {
+  // const inputEl = document.createElement('div')
+  // const vecEl = document.createElement('div')
+  //
+  // inputEl.style.background = 'red'
+  //
+  // inputEl.className = 'comfy-vector-container'
+  // vecEl.className = 'comfy-vector-input'
+  //
+  // vecEl.style.display = 'flex'
+  // inputEl.appendChild(vecEl)
+  const inputs = []
+
+  for (let i = 0; i < vector_size; i++) {
+    // const input = document.createElement('input')
+    // input.type = 'number'
+    // input.value = value[VECTOR_AXIS[i]]
+    const input = node.addWidget(
+      'number',
+      `${name}_${VECTOR_AXIS[i]}`,
+      value[VECTOR_AXIS[i]],
+      (val) => {},
+    )
+
+    inputs.push(input)
+    // vecEl.appendChild(input)
+  }
+  //
+  // const widget = node.addDOMWidget(name, 'vector', inputEl, {
+  //   getValue() {
+  //     return JSON.stringify(widget._value)
+  //   },
+  //   setValue(v) {
+  //     widget._value = v
+  //   },
+  //   afterResize(node, widget) {
+  //     console.log('After resize', { that: this, node, widget })
+  //   },
+  // })
+  //
+  // console.log('prev callback', widget.callback)
+  // widget.callback = callback
+  // widget._value = value
+  //
+  // for (let i = 0; i < vector_size; i++) {
+  //   const input = inputs[i]
+  //   input.addEventListener('change', (event) => {
+  //     widget._value[VECTOR_AXIS[i]] = Number.parseFloat(event.target.value)
+  //     widget.callback?.(widget._value)
+  //     node.graph._version++
+  //     node.setDirtyCanvas(true, true)
+  //   })
+  // }
+  // // document.body.append(inputEl)
+  //
+  // widget.inputEl = inputEl
+  // widget.vecEl = vecEl
+  //
+  // inputEl.addEventListener('input', () => {
+  //   widget.callback?.(widget.value)
+  // })
+  //
+  return { minWidth: 400, minHeight: 200, widget }
+}
+export function addVectorWidget(node, name, value, vector_size, callback, app) {
+  const inputEl = document.createElement('div')
+  const vecEl = document.createElement('div')
+
+  inputEl.className = 'comfy-vector-container'
+  vecEl.className = 'comfy-vector-input'
+  vecEl.id = 'vecEl'
+
+  vecEl.style.display = 'flex'
+  vecEl.style.flexDirection = 'column'
+  inputEl.appendChild(vecEl)
+  const inputs = []
+
+  //
+  // for (let i = 0; i < vector_size; i++) {
+  //   const input = document.createElement('input')
+  //   input.type = 'number'
+  //   input.value = value[VECTOR_AXIS[i]]
+  //   inputs.push(input)
+  //   vecEl.appendChild(input)
+  // }
+
+  const widget = node.addDOMWidget(name, 'vector', inputEl, {
+    getValue() {
+      return JSON.stringify(widget._value)
+    },
+    setValue(v) {
+      widget._value = v
+    },
+  })
+  const vec = new NumberInputWidget('vecEl', vector_size, true)
+  vec.setValue(...Object.values(value))
+  vec.onChange = (value) => {
+    for (let i = 0; i < value.length; i++) {
+      const val = value[i]
+      widget._value[VECTOR_AXIS[i]] = Number.parseFloat(val)
+    }
+
+    widget.callback?.(widget._value)
+    // widget._value[VECTOR_AXIS[index]] = Number.parseFloat(value)
+  }
+
+  console.log('prev callback', widget.callback)
+  widget.callback = callback
+  widget._value = value
+
+  // for (let i = 0; i < vector_size; i++) {
+  //   const input = inputs[i]
+  //   input.addEventListener('change', (event) => {
+  //     widget._value[VECTOR_AXIS[i]] = Number.parseFloat(event.target.value)
+  //     widget.callback?.(widget._value)
+  //     node.graph._version++
+  //     node.setDirtyCanvas(true, true)
+  //   })
+  // }
+
+  widget.inputEl = inputEl
+  widget.vecEl = vecEl
+  widget.vec = vec
+
+  return { minWidth: 400, minHeight: 200 * vector_size, widget }
+}
 export const MtbWidgets = {
+  //TODO: complete this properly
+
+  /**
+   * Creates a vector widget.
+   * @param {string} key - The key for the widget.
+   * @param {number[]} [val] - The initial value for the widget.
+   * @param {number} size - The size of the vector.
+   * @returns {VectorWidget} The vector widget.
+   */
+  VECTOR: (key, val, size) => {
+    shared.infoLogger('Adding VECTOR widget', { key, val, size })
+    /** @type {VectorWidget} */
+    const widget = {
+      name: key,
+      type: `vector${size}`,
+      y: 0,
+      options: { default: Array.from({ length: size }, () => 0.0) },
+      _value: val || Array.from({ length: size }, () => 0.0),
+      draw: function (ctx, node, width, widgetY, height) {
+        ctx.textAlign = 'left'
+        ctx.strokeStyle = outline_color
+        ctx.fillStyle = background_color
+        ctx.beginPath()
+        if (show_text)
+          ctx.roundRect(margin, y, widget_width - margin * 2, H, [H * 0.5])
+        else ctx.rect(margin, y, widget_width - margin * 2, H)
+        ctx.fill()
+        if (show_text) {
+          if (!w.disabled) ctx.stroke()
+          ctx.fillStyle = text_color
+          if (!w.disabled) {
+            ctx.beginPath()
+            ctx.moveTo(margin + 16, y + 5)
+            ctx.lineTo(margin + 6, y + H * 0.5)
+            ctx.lineTo(margin + 16, y + H - 5)
+            ctx.fill()
+            ctx.beginPath()
+            ctx.moveTo(widget_width - margin - 16, y + 5)
+            ctx.lineTo(widget_width - margin - 6, y + H * 0.5)
+            ctx.lineTo(widget_width - margin - 16, y + H - 5)
+            ctx.fill()
+          }
+          ctx.fillStyle = secondary_text_color
+          ctx.fillText(w.label || w.name, margin * 2 + 5, y + H * 0.7)
+          ctx.fillStyle = text_color
+          ctx.textAlign = 'right'
+          if (w.type === 'number') {
+            ctx.fillText(
+              Number(w.value).toFixed(
+                w.options.precision !== undefined ? w.options.precision : 3,
+              ),
+              widget_width - margin * 2 - 20,
+              y + H * 0.7,
+            )
+          } else {
+            let v = w.value
+            if (w.options.values) {
+              let values = w.options.values
+              if (values.constructor === Function) values = values()
+              if (values && values.constructor !== Array) v = values[w.value]
+            }
+            ctx.fillText(v, widget_width - margin * 2 - 20, y + H * 0.7)
+          }
+        }
+      },
+      get value() {
+        return this._value
+      },
+      set value(val) {
+        this._value = val
+        this.callback?.(this._value)
+      },
+    }
+
+    return widget
+  },
   BBOX: (key, val) => {
     /** @type {import("./types/litegraph").IWidget} */
     const widget = {
@@ -297,6 +543,7 @@ export const MtbWidgets = {
 
             picker.addEventListener('change', () => {
               this.value = picker.value
+              this.callback?.(this.value)
               node.graph._version++
               node.setDirtyCanvas(true, true)
               picker.remove()
@@ -409,7 +656,7 @@ const mtb_widgets = {
   name: 'mtb.widgets',
 
   init: async () => {
-    log('Registering mtb.widgets')
+    infoLogger('Registering mtb.widgets')
     try {
       const res = await api.fetchApi('/mtb/debug')
       const msg = await res.json()
@@ -437,13 +684,14 @@ const mtb_widgets = {
         },
       },
       async onChange(value) {
-        if (value) {
-          console.log('Enabled DEBUG mode')
-        }
         if (!window.MTB) {
           window.MTB = {}
         }
         window.MTB.DEBUG = value
+        if (value) {
+          infoLogger('Enabled DEBUG mode')
+        }
+
         await api
           .fetchApi('/mtb/debug', {
             method: 'POST',
@@ -451,7 +699,7 @@ const mtb_widgets = {
               enabled: value,
             }),
           })
-          .then((response) => {})
+          .then((_response) => {})
           .catch((error) => {
             console.error('Error:', error)
           })
@@ -459,9 +707,9 @@ const mtb_widgets = {
     })
   },
 
-  getCustomWidgets: function () {
+  getCustomWidgets: () => {
     return {
-      BOOL: (node, inputName, inputData, app) => {
+      BOOL: (node, inputName, inputData, _app) => {
         console.debug('Registering bool')
 
         return {
@@ -473,7 +721,7 @@ const mtb_widgets = {
         }
       },
 
-      COLOR: (node, inputName, inputData, app) => {
+      COLOR: (node, inputName, inputData, _app) => {
         console.debug('Registering color')
         return {
           widget: node.addCustomWidget(
@@ -495,8 +743,8 @@ const mtb_widgets = {
     }
   },
   /**
-   * @param {import("./types/comfy").NodeType} nodeType
-   * @param {import("./types/comfy").NodeDef} nodeData
+   * @param {NodeType} nodeType
+   * @param {NodeData} nodeData
    * @param {import("./types/comfy").App} app
    */
   async beforeRegisterNodeDef(nodeType, nodeData, app) {
@@ -572,6 +820,10 @@ const mtb_widgets = {
     if (!nodeData.name.endsWith('(mtb)')) {
       return
     }
+    // console.log('MTB Node', { description: nodeData.description, nodeType })
+
+    shared.addDocumentation(nodeData, nodeType)
+
     const deprecation = deprecated_nodes[nodeData.name.replace(' (mtb)', '')]
 
     if (deprecation) {
@@ -579,29 +831,11 @@ const mtb_widgets = {
     }
     //- Extending Python Nodes
     switch (nodeData.name) {
-      case 'Psd Save (mtb)': {
-        const onConnectionsChange = nodeType.prototype.onConnectionsChange
-        nodeType.prototype.onConnectionsChange = function (
-          type,
-          index,
-          connected,
-          link_info,
-        ) {
-          const r = onConnectionsChange
-            ? onConnectionsChange.apply(this, arguments)
-            : undefined
-          shared.dynamic_connection(this, index, connected)
-          return r
-        }
-        break
-      }
       //TODO: remove this non sense
       case 'Get Batch From History (mtb)': {
         const onNodeCreated = nodeType.prototype.onNodeCreated
         nodeType.prototype.onNodeCreated = function () {
-          const r = onNodeCreated
-            ? onNodeCreated.apply(this, arguments)
-            : undefined
+          const r = onNodeCreated ? onNodeCreated.apply(this, []) : undefined
           const internal_count = this.widgets.find(
             (w) => w.name === 'internal_count',
           )
@@ -722,14 +956,11 @@ const mtb_widgets = {
             app.canvas.setDirty(true)
           }
 
-          const reset_button = this.addWidget(
-            'button',
-            `Reset`,
-            'reset',
-            onReset,
-          )
+          // reset button
+          this.addWidget('button', `Reset`, 'reset', onReset)
 
-          const run_button = this.addWidget('button', `Queue`, 'queue', () => {
+          // run button
+          this.addWidget('button', `Queue`, 'queue', () => {
             onReset() // this could maybe be a setting or checkbox
             app.queuePrompt(0, total_frames.value * loop_count.value)
             window.MTB?.notify?.(
@@ -767,23 +998,6 @@ const mtb_widgets = {
 
         break
       }
-      case 'Text Encore Frames (mtb)': {
-        const onConnectionsChange = nodeType.prototype.onConnectionsChange
-        nodeType.prototype.onConnectionsChange = function (
-          type,
-          index,
-          connected,
-          link_info,
-        ) {
-          const r = onConnectionsChange
-            ? onConnectionsChange.apply(this, arguments)
-            : undefined
-
-          shared.dynamic_connection(this, index, connected)
-          return r
-        }
-        break
-      }
       case 'Interpolate Clip Sequential (mtb)': {
         const onNodeCreated = nodeType.prototype.onNodeCreated
         nodeType.prototype.onNodeCreated = function () {
@@ -854,7 +1068,8 @@ const mtb_widgets = {
                     window.MTB?.notify?.(
                       `Extracted positive from ${this.widgets[0].value}`,
                     )
-                    const tn = LiteGraph.createNode('Text box')
+                    // const tn = LiteGraph.createNode('Text box')
+                    const tn = LiteGraph.createNode('CLIPTextEncode')
                     app.graph.add(tn)
                     tn.title = `${this.widgets[0].value} (Positive)`
                     tn.widgets[0].value = style[0]
@@ -875,7 +1090,7 @@ const mtb_widgets = {
                     window.MTB?.notify?.(
                       `Extracted negative from ${this.widgets[0].value}`,
                     )
-                    const tn = LiteGraph.createNode('Text box')
+                    const tn = LiteGraph.createNode('CLIPTextEncode')
                     app.graph.add(tn)
                     tn.title = `${this.widgets[0].value} (Negative)`
                     tn.widgets[0].value = style[1]
@@ -893,14 +1108,28 @@ const mtb_widgets = {
 
         break
       }
+
+      //NOTE: dynamic nodes
       case 'Apply Text Template (mtb)': {
         shared.setupDynamicConnections(nodeType, 'var', '*')
         break
       }
+      case 'Save Data Bundle (mtb)': {
+        shared.setupDynamicConnections(nodeType, 'data', '*') // [MASK,IMAGE]
+        break
+      }
       case 'Add To Playlist (mtb)': {
         shared.setupDynamicConnections(nodeType, 'video', 'VIDEO')
         break
       }
+      case 'Psd Save (mtb)': {
+        shared.setupDynamicConnections(nodeType, 'input_', 'PSDLAYER')
+        break
+      }
+      // case 'Text Encode Frames (mtb)' : {
+      //   shared.setupDynamicConnections(nodeType, 'input_', 'IMAGE')
+      //   break
+      // }
       case 'Stack Images (mtb)':
       case 'Concat Images (mtb)': {
         shared.setupDynamicConnections(nodeType, 'image', 'IMAGE')
@@ -908,6 +1137,7 @@ const mtb_widgets = {
         break
       }
       case 'Batch Float Assemble (mtb)':
+      case 'Batch Float Math (mtb)':
       case 'Plot Batch Float (mtb)': {
         shared.setupDynamicConnections(nodeType, 'floats', 'FLOATS')
         break
@@ -938,11 +1168,9 @@ const mtb_widgets = {
           const r = onConnectionsChange
             ? onConnectionsChange.apply(this, arguments)
             : undefined
-          shared.dynamic_connection(this, index, connected, 'var_', '*', [
-            'x',
-            'y',
-            'z',
-          ])
+          shared.dynamic_connection(this, index, connected, 'var_', '*', {
+            nameArray: ['x', 'y', 'z'],
+          })
 
           //- infer type
           if (link_info) {
@@ -962,6 +1190,33 @@ const mtb_widgets = {
 
         break
       }
+
+      case 'Batch Shape (mtb)':
+      case 'Text To Image (mtb)': {
+        shared.addMenuHandler(nodeType, function (_app, options) {
+          /** @type {ContextMenuItem} */
+          const item = {
+            content: 'swap colors',
+            title: 'Swap BG/FG Color ⚡',
+            callback: (_menuItem) => {
+              const color_w = this.widgets.find((w) => w.name === 'color')
+              const bg_w = this.widgets.find(
+                (w) => w.name === 'background' || w.name === 'bg_color',
+              )
+
+              const color = color_w.value
+              const bg = bg_w.value
+
+              color_w.value = bg
+              bg_w.value = color
+            },
+          }
+
+          options.push(item)
+          return [item]
+        })
+        break
+      }
       case 'Save Tensors (mtb)': {
         const onDrawBackground = nodeType.prototype.onDrawBackground
         nodeType.prototype.onDrawBackground = function (ctx, canvas) {

web/note_plus.js

@@ -140,9 +140,6 @@ const themes = [
   'vscode',
 ]
 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
@@ -487,13 +484,9 @@ 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')
@@ -692,6 +685,9 @@ app.registerExtension({
   registerCustomNodes() {
     LiteGraph.registerNodeType('Note Plus (mtb)', NotePlus)
 
+    NotePlus.category = 'mtb/utils'
+    NotePlus.title = 'Note+ (mtb)'
+
     NotePlus.title_mode = LiteGraph.NO_TITLE
   },
 })

web/numberInput.js

@@ -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()
+  }
+}

web_async/ace/ext-beautify.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-code_lens.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-elastic_tabstops_lite.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-error_marker.js

@@ -0,0 +1,8 @@
+;                (function() {
+                    ace.require(["ace/ext/error_marker"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-hardwrap.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-keybinding_menu.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-linking.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-modelist.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-rtl.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-simple_tokenizer.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-spellcheck.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-split.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-static_highlight.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-statusbar.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-themelist.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/ext-whitespace.js

@@ -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;
+                        }
+                    });
+                })();
+            

web_async/ace/snippets/json.js

@@ -0,0 +1,8 @@
+;                (function() {
+                    ace.require(["ace/snippets/json"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/snippets/json5.js

@@ -0,0 +1,8 @@
+;                (function() {
+                    ace.require(["ace/snippets/json5"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/snippets/markdown.js

@@ -0,0 +1,8 @@
+ace.define("ace/snippets/markdown.snippets",["require","exports","module"],function(e,t,n){n.exports='# Markdown\n\n# Includes octopress (http://octopress.org/) snippets\n\nsnippet [\n	[${1:text}](http://${2:address} "${3:title}")\nsnippet [*\n	[${1:link}](${2:`@*`} "${3:title}")${4}\n\nsnippet [:\n	[${1:id}]: http://${2:url} "${3:title}"\nsnippet [:*\n	[${1:id}]: ${2:`@*`} "${3:title}"\n\nsnippet ![\n	![${1:alttext}](${2:/images/image.jpg} "${3:title}")\nsnippet ![*\n	![${1:alt}](${2:`@*`} "${3:title}")${4}\n\nsnippet ![:\n	![${1:id}]: ${2:url} "${3:title}"\nsnippet ![:*\n	![${1:id}]: ${2:`@*`} "${3:title}"\n\nsnippet ===\nregex /^/=+/=*//\n	${PREV_LINE/./=/g}\n	\n	${0}\nsnippet ---\nregex /^/-+/-*//\n	${PREV_LINE/./-/g}\n	\n	${0}\nsnippet blockquote\n	{% blockquote %}\n	${1:quote}\n	{% endblockquote %}\n\nsnippet blockquote-author\n	{% blockquote ${1:author}, ${2:title} %}\n	${3:quote}\n	{% endblockquote %}\n\nsnippet blockquote-link\n	{% blockquote ${1:author} ${2:URL} ${3:link_text} %}\n	${4:quote}\n	{% endblockquote %}\n\nsnippet bt-codeblock-short\n	```\n	${1:code_snippet}\n	```\n\nsnippet bt-codeblock-full\n	``` ${1:language} ${2:title} ${3:URL} ${4:link_text}\n	${5:code_snippet}\n	```\n\nsnippet codeblock-short\n	{% codeblock %}\n	${1:code_snippet}\n	{% endcodeblock %}\n\nsnippet codeblock-full\n	{% codeblock ${1:title} lang:${2:language} ${3:URL} ${4:link_text} %}\n	${5:code_snippet}\n	{% endcodeblock %}\n\nsnippet gist-full\n	{% gist ${1:gist_id} ${2:filename} %}\n\nsnippet gist-short\n	{% gist ${1:gist_id} %}\n\nsnippet img\n	{% img ${1:class} ${2:URL} ${3:width} ${4:height} ${5:title_text} ${6:alt_text} %}\n\nsnippet youtube\n	{% youtube ${1:video_id} %}\n\n# The quote should appear only once in the text. It is inherently part of it.\n# See http://octopress.org/docs/plugins/pullquote/ for more info.\n\nsnippet pullquote\n	{% pullquote %}\n	${1:text} {" ${2:quote} "} ${3:text}\n	{% endpullquote %}\n'}),ace.define("ace/snippets/markdown",["require","exports","module","ace/snippets/markdown.snippets"],function(e,t,n){"use strict";t.snippetText=e("./markdown.snippets"),t.scope="markdown"});                (function() {
+                    ace.require(["ace/snippets/markdown"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/snippets/python.js

@@ -0,0 +1,8 @@
+ace.define("ace/snippets/python.snippets",["require","exports","module"],function(e,t,n){n.exports='snippet #!\n	#!/usr/bin/env python\nsnippet imp\n	import ${1:module}\nsnippet from\n	from ${1:package} import ${2:module}\n# Module Docstring\nsnippet docs\n	\'\'\'\n	File: ${1:FILENAME:file_name}\n	Author: ${2:author}\n	Description: ${3}\n	\'\'\'\nsnippet wh\n	while ${1:condition}:\n		${2:# TODO: write code...}\n# dowh - does the same as do...while in other languages\nsnippet dowh\n	while True:\n		${1:# TODO: write code...}\n		if ${2:condition}:\n			break\nsnippet with\n	with ${1:expr} as ${2:var}:\n		${3:# TODO: write code...}\n# New Class\nsnippet cl\n	class ${1:ClassName}(${2:object}):\n		"""${3:docstring for $1}"""\n		def __init__(self, ${4:arg}):\n			${5:super($1, self).__init__()}\n			self.$4 = $4\n			${6}\n# New Function\nsnippet def\n	def ${1:fname}(${2:`indent(\'.\') ? \'self\' : \'\'`}):\n		"""${3:docstring for $1}"""\n		${4:# TODO: write code...}\nsnippet deff\n	def ${1:fname}(${2:`indent(\'.\') ? \'self\' : \'\'`}):\n		${3:# TODO: write code...}\n# New Method\nsnippet defs\n	def ${1:mname}(self, ${2:arg}):\n		${3:# TODO: write code...}\n# New Property\nsnippet property\n	def ${1:foo}():\n		doc = "${2:The $1 property.}"\n		def fget(self):\n			${3:return self._$1}\n		def fset(self, value):\n			${4:self._$1 = value}\n# Ifs\nsnippet if\n	if ${1:condition}:\n		${2:# TODO: write code...}\nsnippet el\n	else:\n		${1:# TODO: write code...}\nsnippet ei\n	elif ${1:condition}:\n		${2:# TODO: write code...}\n# For\nsnippet for\n	for ${1:item} in ${2:items}:\n		${3:# TODO: write code...}\n# Encodes\nsnippet cutf8\n	# -*- coding: utf-8 -*-\nsnippet clatin1\n	# -*- coding: latin-1 -*-\nsnippet cascii\n	# -*- coding: ascii -*-\n# Lambda\nsnippet ld\n	${1:var} = lambda ${2:vars} : ${3:action}\nsnippet .\n	self.\nsnippet try Try/Except\n	try:\n		${1:# TODO: write code...}\n	except ${2:Exception}, ${3:e}:\n		${4:raise $3}\nsnippet try Try/Except/Else\n	try:\n		${1:# TODO: write code...}\n	except ${2:Exception}, ${3:e}:\n		${4:raise $3}\n	else:\n		${5:# TODO: write code...}\nsnippet try Try/Except/Finally\n	try:\n		${1:# TODO: write code...}\n	except ${2:Exception}, ${3:e}:\n		${4:raise $3}\n	finally:\n		${5:# TODO: write code...}\nsnippet try Try/Except/Else/Finally\n	try:\n		${1:# TODO: write code...}\n	except ${2:Exception}, ${3:e}:\n		${4:raise $3}\n	else:\n		${5:# TODO: write code...}\n	finally:\n		${6:# TODO: write code...}\n# if __name__ == \'__main__\':\nsnippet ifmain\n	if __name__ == \'__main__\':\n		${1:main()}\n# __magic__\nsnippet _\n	__${1:init}__${2}\n# python debugger (pdb)\nsnippet pdb\n	import pdb; pdb.set_trace()\n# ipython debugger (ipdb)\nsnippet ipdb\n	import ipdb; ipdb.set_trace()\n# ipython debugger (pdbbb)\nsnippet pdbbb\n	import pdbpp; pdbpp.set_trace()\nsnippet pprint\n	import pprint; pprint.pprint(${1})${2}\nsnippet "\n	"""\n	${1:doc}\n	"""\n# test function/method\nsnippet test\n	def test_${1:description}(${2:self}):\n		${3:# TODO: write code...}\n# test case\nsnippet testcase\n	class ${1:ExampleCase}(unittest.TestCase):\n		\n		def test_${2:description}(self):\n			${3:# TODO: write code...}\nsnippet fut\n	from __future__ import ${1}\n#getopt\nsnippet getopt\n	try:\n		# Short option syntax: "hv:"\n		# Long option syntax: "help" or "verbose="\n		opts, args = getopt.getopt(sys.argv[1:], "${1:short_options}", [${2:long_options}])\n	\n	except getopt.GetoptError, err:\n		# Print debug info\n		print str(err)\n		${3:error_action}\n\n	for option, argument in opts:\n		if option in ("-h", "--help"):\n			${4}\n		elif option in ("-v", "--verbose"):\n			verbose = argument\n'}),ace.define("ace/snippets/python",["require","exports","module","ace/snippets/python.snippets"],function(e,t,n){"use strict";t.snippetText=e("./python.snippets"),t.scope="python"});                (function() {
+                    ace.require(["ace/snippets/python"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/snippets/typescript.js

@@ -0,0 +1,8 @@
+;                (function() {
+                    ace.require(["ace/snippets/typescript"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/theme-chaos.js

@@ -0,0 +1,8 @@
+ace.define("ace/theme/chaos-css",["require","exports","module"],function(e,t,n){n.exports=".ace-chaos .ace_gutter {\n  background: #141414;\n  color: #595959;\n  border-right: 1px solid #282828;\n}\n.ace-chaos .ace_gutter-cell.ace_warning {\n  background-image: none;\n  background: #FC0;\n  border-left: none;\n  padding-left: 0;\n  color: #000;\n}\n.ace-chaos .ace_gutter-cell.ace_error {\n  background-position: -6px center;\n  background-image: none;\n  background: #F10;\n  border-left: none;\n  padding-left: 0;\n  color: #000;\n}\n.ace-chaos .ace_print-margin {\n  border-left: 1px solid #555;\n  right: 0;\n  background: #1D1D1D;\n}\n.ace-chaos {\n  background-color: #161616;\n  color: #E6E1DC;\n}\n\n.ace-chaos .ace_cursor {\n  border-left: 2px solid #FFFFFF;\n}\n.ace-chaos .ace_cursor.ace_overwrite {\n  border-left: 0px;\n  border-bottom: 1px solid #FFFFFF;\n}\n.ace-chaos .ace_marker-layer .ace_selection {\n  background: #494836;\n}\n.ace-chaos .ace_marker-layer .ace_step {\n  background: rgb(198, 219, 174);\n}\n.ace-chaos .ace_marker-layer .ace_bracket {\n  margin: -1px 0 0 -1px;\n  border: 1px solid #FCE94F;\n}\n.ace-chaos .ace_marker-layer .ace_active-line {\n  background: #333;\n}\n.ace-chaos .ace_gutter-active-line {\n  background-color: #222;\n}\n.ace-chaos .ace_invisible {\n  color: #404040;\n}\n.ace-chaos .ace_keyword {\n  color:#00698F;\n}\n.ace-chaos .ace_keyword.ace_operator {\n  color:#FF308F;\n}\n.ace-chaos .ace_constant {\n  color:#1EDAFB;\n}\n.ace-chaos .ace_constant.ace_language {\n  color:#FDC251;\n}\n.ace-chaos .ace_constant.ace_library {\n  color:#8DFF0A;\n}\n.ace-chaos .ace_constant.ace_numeric {\n  color:#58C554;\n}\n.ace-chaos .ace_invalid {\n  color:#FFFFFF;\n  background-color:#990000;\n}\n.ace-chaos .ace_invalid.ace_deprecated {\n  color:#FFFFFF;\n  background-color:#990000;\n}\n.ace-chaos .ace_support {\n  color: #999;\n}\n.ace-chaos .ace_support.ace_function {\n  color:#00AEEF;\n}\n.ace-chaos .ace_function {\n  color:#00AEEF;\n}\n.ace-chaos .ace_string {\n  color:#58C554;\n}\n.ace-chaos .ace_comment {\n  color:#555;\n  font-style:italic;\n  padding-bottom: 0px;\n}\n.ace-chaos .ace_variable {\n  color:#997744;\n}\n.ace-chaos .ace_meta.ace_tag {\n  color:#BE53E6;\n}\n.ace-chaos .ace_entity.ace_other.ace_attribute-name {\n  color:#FFFF89;\n}\n.ace-chaos .ace_markup.ace_underline {\n  text-decoration: underline;\n}\n.ace-chaos .ace_fold-widget {\n  text-align: center;\n}\n\n.ace-chaos .ace_fold-widget:hover {\n  color: #777;\n}\n\n.ace-chaos .ace_fold-widget.ace_start,\n.ace-chaos .ace_fold-widget.ace_end,\n.ace-chaos .ace_fold-widget.ace_closed{\n  background: none !important;\n  border: none;\n  box-shadow: none;\n}\n\n.ace-chaos .ace_fold-widget.ace_start:after {\n  content: '\u25be'\n}\n\n.ace-chaos .ace_fold-widget.ace_end:after {\n  content: '\u25b4'\n}\n\n.ace-chaos .ace_fold-widget.ace_closed:after {\n  content: '\u2023'\n}\n\n.ace-chaos .ace_indent-guide {\n  border-right:1px dotted #333333;\n  margin-right:-1px;\n}\n\n.ace-chaos .ace_indent-guide-active {\n  border-right:1px dotted #afafaf;\n  margin-right:-1px;\n}\n\n.ace-chaos .ace_fold { \n  background: #222; \n  border-radius: 3px; \n  color: #7AF; \n  border: none; \n}\n.ace-chaos .ace_fold:hover {\n  background: #CCC; \n  color: #000;\n}\n"}),ace.define("ace/theme/chaos",["require","exports","module","ace/theme/chaos-css","ace/lib/dom"],function(e,t,n){t.isDark=!0,t.cssClass="ace-chaos",t.cssText=e("./chaos-css");var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass,!1)});                (function() {
+                    ace.require(["ace/theme/chaos"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/theme-chrome.js

@@ -0,0 +1,8 @@
+ace.define("ace/theme/chrome-css",["require","exports","module"],function(e,t,n){n.exports='.ace-chrome .ace_gutter {\n  background: #ebebeb;\n  color: #333;\n  overflow : hidden;\n}\n\n.ace-chrome .ace_print-margin {\n  width: 1px;\n  background: #e8e8e8;\n}\n\n.ace-chrome {\n  background-color: #FFFFFF;\n  color: black;\n}\n\n.ace-chrome .ace_cursor {\n  color: black;\n}\n\n.ace-chrome .ace_invisible {\n  color: rgb(191, 191, 191);\n}\n\n.ace-chrome .ace_constant.ace_buildin {\n  color: rgb(88, 72, 246);\n}\n\n.ace-chrome .ace_constant.ace_language {\n  color: rgb(88, 92, 246);\n}\n\n.ace-chrome .ace_constant.ace_library {\n  color: rgb(6, 150, 14);\n}\n\n.ace-chrome .ace_invalid {\n  background-color: rgb(153, 0, 0);\n  color: white;\n}\n\n.ace-chrome .ace_fold {\n}\n\n.ace-chrome .ace_support.ace_function {\n  color: rgb(60, 76, 114);\n}\n\n.ace-chrome .ace_support.ace_constant {\n  color: rgb(6, 150, 14);\n}\n\n.ace-chrome .ace_support.ace_type,\n.ace-chrome .ace_support.ace_class\n.ace-chrome .ace_support.ace_other {\n  color: rgb(109, 121, 222);\n}\n\n.ace-chrome .ace_variable.ace_parameter {\n  font-style:italic;\n  color:#FD971F;\n}\n.ace-chrome .ace_keyword.ace_operator {\n  color: rgb(104, 118, 135);\n}\n\n.ace-chrome .ace_comment {\n  color: #236e24;\n}\n\n.ace-chrome .ace_comment.ace_doc {\n  color: #236e24;\n}\n\n.ace-chrome .ace_comment.ace_doc.ace_tag {\n  color: #236e24;\n}\n\n.ace-chrome .ace_constant.ace_numeric {\n  color: rgb(0, 0, 205);\n}\n\n.ace-chrome .ace_variable {\n  color: rgb(49, 132, 149);\n}\n\n.ace-chrome .ace_xml-pe {\n  color: rgb(104, 104, 91);\n}\n\n.ace-chrome .ace_entity.ace_name.ace_function {\n  color: #0000A2;\n}\n\n\n.ace-chrome .ace_heading {\n  color: rgb(12, 7, 255);\n}\n\n.ace-chrome .ace_list {\n  color:rgb(185, 6, 144);\n}\n\n.ace-chrome .ace_marker-layer .ace_selection {\n  background: rgb(181, 213, 255);\n}\n\n.ace-chrome .ace_marker-layer .ace_step {\n  background: rgb(252, 255, 0);\n}\n\n.ace-chrome .ace_marker-layer .ace_stack {\n  background: rgb(164, 229, 101);\n}\n\n.ace-chrome .ace_marker-layer .ace_bracket {\n  margin: -1px 0 0 -1px;\n  border: 1px solid rgb(192, 192, 192);\n}\n\n.ace-chrome .ace_marker-layer .ace_active-line {\n  background: rgba(0, 0, 0, 0.07);\n}\n\n.ace-chrome .ace_gutter-active-line {\n    background-color : #dcdcdc;\n}\n\n.ace-chrome .ace_marker-layer .ace_selected-word {\n  background: rgb(250, 250, 255);\n  border: 1px solid rgb(200, 200, 250);\n}\n\n.ace-chrome .ace_storage,\n.ace-chrome .ace_keyword,\n.ace-chrome .ace_meta.ace_tag {\n  color: rgb(147, 15, 128);\n}\n\n.ace-chrome .ace_string.ace_regex {\n  color: rgb(255, 0, 0)\n}\n\n.ace-chrome .ace_string {\n  color: #1A1AA6;\n}\n\n.ace-chrome .ace_entity.ace_other.ace_attribute-name {\n  color: #994409;\n}\n\n.ace-chrome .ace_indent-guide {\n  background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAE0lEQVQImWP4////f4bLly//BwAmVgd1/w11/gAAAABJRU5ErkJggg==") right repeat-y;\n}\n  \n.ace-chrome .ace_indent-guide-active {\n  background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAIGNIUk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5JfxUYAAAAZSURBVHjaYvj///9/hivKyv8BAAAA//8DACLqBhbvk+/eAAAAAElFTkSuQmCC") right repeat-y;\n}\n'}),ace.define("ace/theme/chrome",["require","exports","module","ace/theme/chrome-css","ace/lib/dom"],function(e,t,n){t.isDark=!1,t.cssClass="ace-chrome",t.cssText=e("./chrome-css");var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass,!1)});                (function() {
+                    ace.require(["ace/theme/chrome"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/theme-cloud9_day.js

@@ -0,0 +1,8 @@
+ace.define("ace/theme/cloud9_day-css",["require","exports","module"],function(e,t,n){n.exports='.ace-cloud9-day .ace_gutter {\n    background: #ECECEC;\n    color: #333;\n}\n\n.ace-cloud9-day .ace_print-margin {\n    width: 1px;\n    background: #e8e8e8;\n}\n\n.ace-cloud9-day .ace_fold {\n    background-color: #6B72E6;\n}\n\n.ace-cloud9-day {\n    background-color: #FBFBFB;\n    color: black;\n}\n\n.ace-cloud9-day .ace_cursor {\n    color: black;\n}\n\n.ace-cloud9-day .ace_invisible {\n    color: rgb(191, 191, 191);\n}\n\n.ace-cloud9-day .ace_storage,\n.ace-cloud9-day .ace_keyword {\n    color: rgb(24, 122, 234);\n}\n\n.ace-cloud9-day .ace_constant {\n    color: rgb(197, 6, 11);\n}\n\n.ace-cloud9-day .ace_constant.ace_buildin {\n    color: rgb(88, 72, 246);\n}\n\n.ace-cloud9-day .ace_constant.ace_language {\n    color: rgb(88, 92, 246);\n}\n\n.ace-cloud9-day .ace_constant.ace_library {\n    color: rgb(6, 150, 14);\n}\n\n.ace-cloud9-day .ace_invalid {\n    background-color: rgba(255, 0, 0, 0.1);\n    color: red;\n}\n\n.ace-cloud9-day .ace_support.ace_function {\n    color: rgb(60, 76, 114);\n}\n\n.ace-cloud9-day .ace_support.ace_constant {\n    color: rgb(6, 150, 14);\n}\n\n.ace-cloud9-day .ace_support.ace_type,\n.ace-cloud9-day .ace_support.ace_class {\n    color: rgb(109, 121, 222);\n}\n\n.ace-cloud9-day .ace_keyword.ace_operator {\n    color: rgb(104, 118, 135);\n}\n\n.ace-cloud9-day .ace_string {\n    color: rgb(3, 106, 7);\n}\n\n.ace-cloud9-day .ace_comment {\n    color: rgb(76, 136, 107);\n}\n\n.ace-cloud9-day .ace_comment.ace_doc {\n    color: rgb(0, 102, 255);\n}\n\n.ace-cloud9-day .ace_comment.ace_doc.ace_tag {\n    color: rgb(128, 159, 191);\n}\n\n.ace-cloud9-day .ace_constant.ace_numeric {\n    color: rgb(0, 0, 205);\n}\n\n.ace-cloud9-day .ace_variable {\n    color: rgb(49, 132, 149);\n}\n\n.ace-cloud9-day .ace_xml-pe {\n    color: rgb(104, 104, 91);\n}\n\n.ace-cloud9-day .ace_entity.ace_name.ace_function {\n    color: #0000A2;\n}\n\n\n.ace-cloud9-day .ace_heading {\n    color: rgb(12, 7, 255);\n}\n\n.ace-cloud9-day .ace_list {\n    color: rgb(185, 6, 144);\n}\n\n.ace-cloud9-day .ace_meta.ace_tag {\n    color: rgb(0, 22, 142);\n}\n\n.ace-cloud9-day .ace_string.ace_regex {\n    color: rgb(255, 0, 0)\n}\n\n.ace-cloud9-day .ace_marker-layer .ace_selection {\n    background: rgb(181, 213, 255);\n}\n\n.ace-cloud9-day.ace_multiselect .ace_selection.ace_start {\n    box-shadow: 0 0 3px 0px white;\n}\n\n.ace-cloud9-day .ace_marker-layer .ace_step {\n    background: rgb(247, 237, 137);\n}\n\n.ace-cloud9-day .ace_marker-layer .ace_stack {\n    background: #BAE0A0;\n}\n\n.ace-cloud9-day .ace_marker-layer .ace_bracket {\n    margin: -1px 0 0 -1px;\n    border: 1px solid rgb(192, 192, 192);\n}\n\n.ace-cloud9-day .ace_marker-layer .ace_active-line {\n    background: rgba(0, 0, 0, 0.07);\n}\n\n.ace-cloud9-day .ace_gutter-active-line {\n    background-color: #E5E5E5;\n}\n\n.ace-cloud9-day .ace_marker-layer .ace_selected-word {\n    background: rgb(250, 250, 255);\n    border: 1px solid rgb(200, 200, 250);\n}\n\n.ace-cloud9-day .ace_indent-guide {\n    background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAE0lEQVQImWP4////f4bLly//BwAmVgd1/w11/gAAAABJRU5ErkJggg==") right repeat-y;\n}\n\n.ace-cloud9-day .ace_indent-guide-active {\n  background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAIGNIUk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5JfxUYAAAAZSURBVHjaYvj///9/hivKyv8BAAAA//8DACLqBhbvk+/eAAAAAElFTkSuQmCC") right repeat-y;\n} \n'}),ace.define("ace/theme/cloud9_day",["require","exports","module","ace/theme/cloud9_day-css","ace/lib/dom"],function(e,t,n){"use strict";t.isDark=!1,t.cssClass="ace-cloud9-day",t.cssText=e("./cloud9_day-css");var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)});                (function() {
+                    ace.require(["ace/theme/cloud9_day"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

web_async/ace/theme-cloud9_night.js

@@ -0,0 +1,8 @@
+ace.define("ace/theme/cloud9_night-css",["require","exports","module"],function(e,t,n){n.exports=".ace-cloud9-night .ace_gutter {\n    background: #303130;\n    color: #eee\n}\n\n.ace-cloud9-night .ace_print-margin {\n    width: 1px;\n    background: #222\n}\n\n.ace-cloud9-night {\n    background-color: #181818;\n    color: #EBEBEB\n}\n\n.ace-cloud9-night .ace_cursor {\n    color: #9F9F9F\n}\n\n.ace-cloud9-night .ace_marker-layer .ace_selection {\n    background: #424242\n}\n\n.ace-cloud9-night.ace_multiselect .ace_selection.ace_start {\n    box-shadow: 0 0 3px 0px #000000;\n    border-radius: 2px\n}\n\n.ace-cloud9-night .ace_marker-layer .ace_step {\n    background: rgb(102, 82, 0)\n}\n\n.ace-cloud9-night .ace_marker-layer .ace_bracket {\n    margin: -1px 0 0 -1px;\n    border: 1px solid #888888\n}\n\n.ace-cloud9-night .ace_marker-layer .ace_highlight {\n    border: 1px solid rgb(110, 119, 0);\n    border-bottom: 0;\n    box-shadow: inset 0 -1px rgb(110, 119, 0);\n    margin: -1px 0 0 -1px;\n    background: rgba(255, 235, 0, 0.1);\n}\n\n.ace-cloud9-night .ace_marker-layer .ace_active-line {\n    background: #292929\n}\n\n.ace-cloud9-night .ace_gutter-active-line {\n    background-color: #3D3D3D\n}\n\n.ace-cloud9-night .ace_stack {\n    background-color: rgb(66, 90, 44)\n}\n\n.ace-cloud9-night .ace_marker-layer .ace_selected-word {\n    border: 1px solid #888888\n}\n\n.ace-cloud9-night .ace_invisible {\n    color: #343434\n}\n\n.ace-cloud9-night .ace_keyword,\n.ace-cloud9-night .ace_meta,\n.ace-cloud9-night .ace_storage,\n.ace-cloud9-night .ace_storage.ace_type,\n.ace-cloud9-night .ace_support.ace_type {\n    color: #C397D8\n}\n\n.ace-cloud9-night .ace_keyword.ace_operator {\n    color: #70C0B1\n}\n\n.ace-cloud9-night .ace_constant.ace_character,\n.ace-cloud9-night .ace_constant.ace_language,\n.ace-cloud9-night .ace_constant.ace_numeric,\n.ace-cloud9-night .ace_keyword.ace_other.ace_unit,\n.ace-cloud9-night .ace_support.ace_constant,\n.ace-cloud9-night .ace_variable.ace_parameter {\n    color: #E78C45\n}\n\n.ace-cloud9-night .ace_constant.ace_other {\n    color: #EEEEEE\n}\n\n.ace-cloud9-night .ace_invalid {\n    color: #CED2CF;\n    background-color: #DF5F5F\n}\n\n.ace-cloud9-night .ace_invalid.ace_deprecated {\n    color: #CED2CF;\n    background-color: #B798BF\n}\n\n.ace-cloud9-night .ace_fold {\n    background-color: #7AA6DA;\n    border-color: #DEDEDE\n}\n\n.ace-cloud9-night .ace_entity.ace_name.ace_function,\n.ace-cloud9-night .ace_support.ace_function,\n.ace-cloud9-night .ace_variable:not(.ace_parameter),\n.ace-cloud9-night .ace_constant:not(.ace_numeric) {\n    color: #7AA6DA\n}\n\n.ace-cloud9-night .ace_support.ace_class,\n.ace-cloud9-night .ace_support.ace_type {\n    color: #E7C547\n}\n\n.ace-cloud9-night .ace_heading,\n.ace-cloud9-night .ace_markup.ace_heading,\n.ace-cloud9-night .ace_string {\n    color: #B9CA4A\n}\n\n.ace-cloud9-night .ace_entity.ace_name.ace_tag,\n.ace-cloud9-night .ace_entity.ace_other.ace_attribute-name,\n.ace-cloud9-night .ace_meta.ace_tag,\n.ace-cloud9-night .ace_string.ace_regexp,\n.ace-cloud9-night .ace_variable {\n    color: #D54E53\n}\n\n.ace-cloud9-night .ace_comment {\n    color: #969896\n}\n\n.ace-cloud9-night .ace_c9searchresults.ace_keyword {\n    color: #C2C280;\n}\n\n.ace-cloud9-night .ace_indent-guide {\n    background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQImWNgYGBgYFBXV/8PAAJoAXX4kT2EAAAAAElFTkSuQmCC) right repeat-y\n}\n\n.ace-cloud9-night .ace_indent-guide-active {\n    background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQIW2PQ1dX9zzBz5sz/ABCcBFFentLlAAAAAElFTkSuQmCC) right repeat-y;\n}\n"}),ace.define("ace/theme/cloud9_night",["require","exports","module","ace/theme/cloud9_night-css","ace/lib/dom"],function(e,t,n){t.isDark=!0,t.cssClass="ace-cloud9-night",t.cssText=e("./cloud9_night-css");var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)});                (function() {
+                    ace.require(["ace/theme/cloud9_night"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+