diff --git a/.github/skills/check-processing/SKILL.md b/.github/skills/check-processing/SKILL.md index 78efd8e47..73db5636c 100644 --- a/.github/skills/check-processing/SKILL.md +++ b/.github/skills/check-processing/SKILL.md @@ -27,7 +27,7 @@ Run workflow coverage in this order to keep checks focused and complete: 2. `img2img`: `modules/ui_img2img.py` -> `modules/img2img.py` -> `modules/processing.py:process_images` -> `modules/processing_diffusers.py:process_diffusers` 3. `control/process`: `modules/ui_control.py` -> `modules/control/run.py` (and related control processing entrypoints) -> `modules/processing.py:process_images` -> `modules/processing_diffusers.py:process_diffusers` 4. `caption/process`: `modules/ui_caption.py` -> caption handler module(s) -> `modules/processing.py:process_images` and/or postprocess/caption execution module(s), depending on selected caption backend -5. `video`: `modules/ui_video.py` -> `modules/video_models/video_run -> `modules/processing.py:process_images` and/or postprocess/video execution module(s), depending on implementation +5. `video`: `modules/ui_video.py` -> `modules/video_models/video_run.py` -> `modules/processing.py:process_images` and/or postprocess/video execution module(s), depending on implementation Also validate script hooks when present: @@ -40,8 +40,10 @@ Also validate script hooks when present: - `modules/ui_img2img.py` - `modules/img2img.py` - `modules/ui_control.py` -- `modules/ui_caption.py` (and `modules/ui_captions.py` if present) - `modules/control/run.py` +- `modules/ui_caption.py` +- `modules/ui_video.py` +- `modules/video_models/video_run.py` - `modules/processing.py` - `modules/processing_diffusers.py` - `modules/scripts_manager.py` @@ -58,7 +60,7 @@ For each covered workflow, verify all three dimensions: ### 1. Build End-To-End Call Graph -For each workflow (`txt2img`, `img2img`, `control`, `caption`): +For each workflow (`txt2img`, `img2img`, `control`, `caption`, `video`): - Locate submit/click bindings in UI modules. - Capture the exact `inputs=[...]` list order and target function (`fn=...`). diff --git a/.gitignore b/.gitignore index ef7675389..79ca34de5 100644 --- a/.gitignore +++ b/.gitignore @@ -6,7 +6,6 @@ __pycache__ .idea/ **/.DS_Store /*.json -/*.yaml /params.txt /styles.csv /user.css @@ -18,6 +17,8 @@ __pycache__ /data/themes.json /data/installer.json /data/rocm.json +/data/signatures.json +/data/civitai.json node_modules package-lock.json @@ -60,6 +61,7 @@ tunableop_results*.csv !requirements.txt !constraints.txt !pnpm-lock.yaml +!pnpm-workspace.yaml !/data !/models/VAE-approx !/models/VAE-approx/model.pt diff --git a/.vscode/settings.json b/.vscode/settings.json index 99b079518..cdd6c1667 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -20,5 +20,6 @@ }, "githubPullRequests.ignoredPullRequestBranches": [ "master" - ] + ], + "chat.byokUtilityModelDefault": "mainAgent" } diff --git a/CHANGELOG.md b/CHANGELOG.md index 6b438eeca..b48318abb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,9 +1,49 @@ # Change Log for SD.Next -## Update for 2026-07-08 +## Update for 2026-07-14 +### Highlights for 2026-07-14 + +*What's New?* Full week(!) since there release, we're bringing a service pack update: +**Anima** has new *Aesthetic* and *Turbo* variants, **Joy Image Edit** has new *Plus* variant +*And also*: +- UI updates to *Server info* and *Log viewer*, more informative and allows easier sharing of info +- Quite a few *SDNQ* improvements, both to quantization and attention +- Continuing with enhanced support for 3rd party finetunes + +*Note*: As long as there are no major items in `#dev` branch, we will continue with weekly service updates, so stay tuned for more! + +[Home](https://vladmandic.github.io/sdnext/) | [ChangeLog](https://github.com/vladmandic/automatic/blob/master/CHANGELOG.md) | [Docs](https://vladmandic.github.io/sdnext-docs/) | [Discord](https://discord.com/invite/sd-next-federal-batch-inspectors-1101998836328697867) | [Sponsor](https://github.com/sponsors/vladmandic) + +### Details for 2026-07-14 + +- **Models** + - [Anima 1.0](https://civitai.com/models/2458426/anima?modelVersionId=3108569) new *Aesthetic* and *Turbo* variants + - [Joy Image Edit](https://huggingface.co/jdopensource/JoyAI-Image-Edit-Plus-Diffusers) new *Plus* variant that has multi-image-edit capabilities - **Features** - - api add `/sdapi/v1/restart` endpoint + - loader: support loading secondary unet for models that have multiple unets + *networks panel -> toggle: load model as secondary model* + *settings -> model loading -> unet model secondary* + - loader: support transformers from all-in-one safetensors + - loader: improve `fp8` model support + - loader: improve `nvfp4` model support + - lora: additional lora types + - civitai: improve search + - civitai: restart download + - sdnq: improve attention + - api: add `/sdapi/v1/restart` endpoint + - server: strict sub-path mount and redirects for all endpoints +- **UI** + - improved server info panel + now shows loaded components, networks, etc. + - improved log viewer for both server and client logs + - expose server errors + - log view copy server log and copy client log buttons + copies current log to clipboard for easy sharing + - collapsible input & output panels for *video*, *caption*, *process* tabs + - video add immediate load +- **Experimental** + - support for `comfy_quant` models - **Fixes** - huggingface: fix model access on windows - lora: fix lora text-encoder loader @@ -11,6 +51,13 @@ - api: validate swagger schema - installer: handle detached branch on non-english setups - fs: faster stat + - server-info: handle multiple gpus + - load: skip redundant model reload + - sdnq: fix hadamard on sdnq atten with sd15 + - download: improved progress tracking + - gallery: delete image + - gallery: save image + - standardui: gallery collapse sections ## Update for 2026-07-07 diff --git a/TODO.md b/TODO.md index a9ff6844a..57e2c4509 100644 --- a/TODO.md +++ b/TODO.md @@ -8,7 +8,6 @@ ### Assigned -- [Object clear](https://huggingface.co/jixin0101/ObjectClear) remover for Kanvas, @vladmandic - Chat-based interface, @vladmandic - Control tab verify overrides handling, @vladmandic - Cloud providers, @CalamitousFelicitousness @@ -17,10 +16,13 @@ ### Unassigned +- [Nunchaku Lite](https://github.com/huggingface/diffusers/pull/14100) - Processing -> Video capabilities - `RIFE` in processing - `SeedVR2` in processing -- Video model loader: Add video models to Reference +- [Object clear](https://huggingface.co/jixin0101/ObjectClear) remover for Kanvas +- Video models: add to Reference +- Video models: support custom entries - UI Lite vs Expert mode - Auto handle scheduler `prediction_type` - Cache models in memory diff --git a/cli/sdnq-attention-benchmark.py b/cli/sdnq-attention-benchmark.py new file mode 100755 index 000000000..db95417c9 --- /dev/null +++ b/cli/sdnq-attention-benchmark.py @@ -0,0 +1,3025 @@ +#!/usr/bin/env python +""" +Benchmark and validate SDNQ attention and weight dequantization on the local GPU. + +The attention section runs the kernel from modules/sdnq/kernels/triton_atten.py directly and +compares speed and numerical error against torch scaled_dot_product_attention and +sageattention when installed. Verifies mask, causal, GQA, cross-attention and padding code +paths, probes float8 hardware support and the torch.compile input prep, and prints +recommended values for the Compute Settings -> SDNQ Attention section. + +The dequant section builds real SDNQ linear layers per storage dtype (int8, uint4, +float8_e4m3fn, float8_e4m3fn_sdnq, float4_e2m1fn) at Krea 2 and Qwen3 TE layer geometry and +measures eager vs compiled weight dequantization plus the full linear forward with and +without quantized matmul, against a bf16 nn.Linear baseline. For float storage dtypes it +also measures quantized matmul with the MatMul type set explicitly (int8, float16), since +auto routes them to fp8 matmul, which not every gpu can run. Setting sweeps +(--dequant-sweeps) cover group size, svd rank, weight-side hadamard group size, dequantize +full precision off, dynamic quantization, cpu quantize time and conv2d quantization. Probes +whether compiled dequant of fp8 storage works on this GPU (triton before sm_89 lacks e4m3 +conversions) and prints recommended values for the Compute Settings -> SDNQ section. + +The block section measures complete configurations (weights dtype x matmul path x attention) +end to end through a dit-style transformer block, with output error at depth one and four +against an fp32 reference block, because component speedups and errors do not compose +multiplicatively. + +Benchmarks run in the webui's configured dtype (--dtype overrides). The prep column is the +q/k/v quantization cost outside the kernel, included in the median. Recommendations come +from measured comparisons only. + +Shape presets follow real model geometries: sd15, sdxl, sdxl-cross, qwen3-te (Anima TE), +anima, flux2 (Klein), wan22 (A14B), ltx2 (LTX 2.3), plus masked and wan22-cfg presets. Run +from the sdnext root with the venv active: + python cli/sdnq-attention-benchmark.py + python cli/sdnq-attention-benchmark.py --shapes all --json results.json + python cli/sdnq-attention-benchmark.py --sections dequant + python cli/sdnq-attention-benchmark.py --shapes wan22,ltx2 --iters 20 + +The first run of each shape includes triton autotune and torch.compile time; results are +cached on disk and reused by the webui for matching shapes. +""" + +import os +import sys +import json +import math +import time +import signal +import logging +import argparse +import importlib.metadata +from contextlib import contextmanager + +import torch +from rich import box +from rich.console import Console, Group +from rich.live import Live +from rich.markup import escape +from rich.panel import Panel +from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn +from rich.table import Table + + +console = Console(width=None if sys.stdout.isatty() else 140) # keep tables readable when piped to a file +ROUNDED_BOX = box.ROUNDED # modules.logger monkeypatches rich's box.ROUNDED to box.SIMPLE at import; keep the real one for panels +shared = None +devices = None +sdnq_triton_atten = None +bench_dtype = torch.bfloat16 # resolved to the webui's configured dtype in main +transcript = [] # final tables and panels, written out by --save +report = {} # structured results mirroring the tables, written out by --json +compiled_dequantize_weight = None # tool-owned compiled variant, built on first use + +torch_device_module = torch.xpu if torch.xpu.is_available() else torch.cuda +torch_device = "xpu" if torch.xpu.is_available() else "cuda" + + +def dtype_label(): + return str(bench_dtype).replace("torch.", "") + + +def emit(renderable): + console.print(renderable) + transcript.append(renderable) + + +def save_transcript(path): + with open(path, "w", encoding="utf-8") as fh: + file_console = Console(file=fh, width=140) # file consoles are non-terminal: markup renders to plain text + for renderable in transcript: + file_console.print(renderable) + console.print(f"results saved to {path}") + +shape_presets = { + # geometry from the model transformer and text-encoder configs; + # optional keys: kv_tokens (cross-attention), kv_heads (gqa), causal + "sd15": dict(batch=2, heads=8, tokens=4096, head_dim=40, desc="SD 1.5 unet self-attention at 512px, batched cfg, head dim padded 40 to 64"), + "sdxl": dict(batch=2, heads=10, tokens=4096, head_dim=64, desc="SDXL unet self-attention at 1024px, batched cfg"), + "sdxl-cross": dict(batch=2, heads=10, tokens=4096, kv_tokens=77, head_dim=64, desc="SDXL unet cross-attention at 1024px, 77 text tokens"), + "qwen3-te": dict(batch=2, heads=16, kv_heads=8, tokens=512, head_dim=128, causal=True, desc="Qwen3 text encoder (Anima), causal gqa 16:8 heads, 512 token prompt"), + "anima": dict(batch=1, heads=16, tokens=4096, head_dim=128, desc="Anima 1.0 self-attention at 1024px, one cfg pass"), + "flux2": dict(batch=1, heads=32, tokens=4608, head_dim=128, desc="FLUX.2 Klein 9B joint attention at 1024px, 4096 image plus 512 text tokens"), + "wan22": dict(batch=1, heads=40, tokens=32760, head_dim=128, desc="Wan 2.2 A14B self-attention, 832x480 81 frames, one cfg pass"), + "wan22-cfg": dict(batch=2, heads=40, tokens=32760, head_dim=128, desc="Wan 2.2 A14B self-attention, 832x480 81 frames, batched cfg"), + "ltx2": dict(batch=1, heads=32, tokens=13376, head_dim=128, desc="LTX 2.3 self-attention, 1216x704 121 frames, one cfg pass"), + "masked": dict(batch=1, heads=32, tokens=4608, head_dim=128, desc="FLUX.2 Klein shape with boolean key-padding mask, 25% of keys masked"), +} +full_run = ["sd15", "sdxl", "sdxl-cross", "qwen3-te", "anima", "flux2", "wan22", "ltx2"] +# settings advice comes from a self-attention shape with the full config set; cross-attention +# and text-encoder shapes measure the hijack's cost there but would mislead as global advice +recommendation_presets = ["flux2", "anima", "sdxl", "wan22", "ltx2", "sd15"] +default_shapes = "sdxl,flux2" +all_sections = ["attention", "dequant", "block"] + +# combined block benchmark: a dit-style transformer block at krea 2 class geometry, so each row +# measures a complete configuration of weights dtype x matmul path x attention end to end +block_geometry = dict(hidden=3072, heads=24, mlp_dim=16384, tokens=4096) +block_attention_specs = { + "sdpa": None, # stock torch sdpa + "atten int8": dict(matmul_dtype="auto", pv_matmul_dtype="auto"), + "atten int8 smooth": dict(matmul_dtype="auto", pv_matmul_dtype="auto", smooth_k=True), + "atten int8 hadamard": dict(matmul_dtype="auto", pv_matmul_dtype="auto", use_hadamard=True), + "atten full": dict(matmul_dtype="auto", pv_matmul_dtype="int8", smooth_k=True, use_hadamard=True), + "sage": "sage", # external baselines, resolved to the sage wrappers in build_bench_block + "sage fp16 accum": "sagefp16", +} +# id, weights config (None = bf16), use quantized matmul, attention spec; fp8/fp4 rows use the +# dequant path: quantized matmul auto-selects fp8 for float dtypes, unsupported before sm_89 +block_configs = [ + ("bf16", None, False, "sdpa"), + ("bf16-atten", None, False, "atten int8"), + ("bf16-sage", None, False, "sage"), + ("bf16-sagefp16", None, False, "sage fp16 accum"), + ("int8", dict(weights_dtype="int8"), False, "sdpa"), + ("int8-mm", dict(weights_dtype="int8"), True, "sdpa"), + ("int8-mm-atten", dict(weights_dtype="int8"), True, "atten int8"), + ("int8-mm-smooth", dict(weights_dtype="int8"), True, "atten int8 smooth"), + ("int8-mm-hadamard", dict(weights_dtype="int8"), True, "atten int8 hadamard"), + ("int8-mm-atten-full", dict(weights_dtype="int8"), True, "atten full"), + ("int8-mm-sage", dict(weights_dtype="int8"), True, "sage"), + ("int8-mm-sagefp16", dict(weights_dtype="int8"), True, "sage fp16 accum"), + ("int6", dict(weights_dtype="int6"), False, "sdpa"), + ("uint4-mm", dict(weights_dtype="uint4"), True, "sdpa"), + ("uint4-mm-atten", dict(weights_dtype="uint4"), True, "atten int8"), + ("fp8sdnq", dict(weights_dtype="float8_e4m3fn_sdnq"), False, "sdpa"), + ("fp8sdnq-atten", dict(weights_dtype="float8_e4m3fn_sdnq"), False, "atten int8"), + ("nvfp4", dict(weights_dtype="float4_e2m1fn", group_size=16), False, "sdpa"), + ("nvfp4-atten", dict(weights_dtype="float4_e2m1fn", group_size=16), False, "atten int8"), +] + +# benchmark configs: id, label, kwargs for sdnq_triton_atten (None = external baseline); +# fp8 configs run only on gpus where the float8 probe passes +bench_configs = [ + ("base", "torch sdpa", None), + ("sage", "sageattention", None), + ("sagefp16", "sage fp16 accum", None), + ("amdflash", "triton flash (amd)", None), + ("noquant", "sdnq, quantized matmul off", dict(do_quantize=False)), + ("int8", "sdnq int8 qk", dict(matmul_dtype="auto", pv_matmul_dtype="auto")), + ("smooth", "sdnq int8 qk + smooth k", dict(matmul_dtype="auto", pv_matmul_dtype="auto", smooth_k=True)), + ("hadamard", "sdnq int8 qk + hadamard", dict(matmul_dtype="auto", pv_matmul_dtype="auto", use_hadamard=True)), + ("smooth_hadamard", "sdnq int8 qk + smooth + hadamard", dict(matmul_dtype="auto", pv_matmul_dtype="auto", smooth_k=True, use_hadamard=True)), + ("fp16pv", "sdnq int8 qk + fp16 pv", dict(matmul_dtype="auto", pv_matmul_dtype="float16")), + ("int8pv", "sdnq int8 qk + int8 pv", dict(matmul_dtype="auto", pv_matmul_dtype="int8")), + ("fp8pv", "sdnq int8 qk + fp8 pv", dict(matmul_dtype="auto", pv_matmul_dtype="float8_e4m3fn")), + ("full", "sdnq int8 qk + smooth + hadamard + int8 pv", dict(matmul_dtype="auto", pv_matmul_dtype="int8", smooth_k=True, use_hadamard=True)), + ("fp16qk", "sdnq fp16 qk", dict(matmul_dtype="float16", pv_matmul_dtype="auto")), + ("fp8qk", "sdnq fp8 qk", dict(matmul_dtype="float8_e4m3fn", pv_matmul_dtype="auto")), + ("fp8full", "sdnq fp8 qk + fp8 pv", dict(matmul_dtype="float8_e4m3fn", pv_matmul_dtype="float8_e4m3fn")), +] +# external baselines are compared against but never starred or recommended as sdnq configs +external_config_ids = ("base", "sage", "sagefp16", "amdflash") +video_config_ids = ["base", "sage", "sagefp16", "amdflash", "noquant", "int8", "smooth", "hadamard", "fp16pv", "int8pv", "fp8pv", "full"] +masked_config_ids = ["base", "noquant", "int8"] +# hadamard configs excluded: compiling hadamard with a non pow2 head dim currently hangs torch inductor +sd15_config_ids = ["base", "amdflash", "noquant", "int8", "smooth", "fp16pv", "int8pv", "fp8pv", "fp16qk", "fp8qk"] + +# weight dequant benchmark geometry: krea 2 12b linear layers plus the qwen3 1.7b (anima te) +# gate/up projection, so the te override settings get numbers at text-encoder geometry +dequant_shapes = [ + ("qkv 6144x3072", 6144, 3072), + ("mlp 16384x3072", 16384, 3072), + ("te mlp 6144x2048", 6144, 2048), +] +dequant_forward_tokens = 4096 # rows of the forward-bench input, one 1024px image worth of tokens +# id, label, sdnq config kwargs; int8 first: the ui default and the dominant pre-quantized format +dequant_dtype_configs = [ + ("int8", "int8", dict(weights_dtype="int8")), + ("uint8", "uint8", dict(weights_dtype="uint8")), + ("int6", "int6", dict(weights_dtype="int6")), + ("uint6", "uint6", dict(weights_dtype="uint6")), + ("int4", "int4", dict(weights_dtype="int4")), + ("uint4", "uint4", dict(weights_dtype="uint4")), + ("int2", "int2", dict(weights_dtype="int2")), + ("uint2", "uint2", dict(weights_dtype="uint2")), + ("fp8", "float8_e4m3fn", dict(weights_dtype="float8_e4m3fn")), + ("fp8sdnq", "float8_e4m3fn_sdnq", dict(weights_dtype="float8_e4m3fn_sdnq")), + ("nvfp4", "float4_e2m1fn g16", dict(weights_dtype="float4_e2m1fn", group_size=16)), +] +# svd/hadamard variants measured on top of these dtypes at the first dequant shape; low bits are +# where rotation is expected to pay, int8 is the control +dequant_variant_dtypes = ["int8", "uint4", "uint2"] +dequant_variant_configs = [ + ("hadamard", dict(use_hadamard=True)), + ("svd", dict(use_svd=True)), + ("svd+hadamard", dict(use_svd=True, use_hadamard=True)), +] +# float storage dtypes route quantized matmul to fp8 under auto; measure the explicit MatMul +# type alternatives so advice on gpus without fp8 matmul cites numbers instead of escape hatches +float_mm_dtypes = ["fp8", "fp8sdnq", "nvfp4"] +float_mm_alternative_dtypes = ["int8", "float16"] +# setting sweeps for the remaining measurable SDNQ options, each at the first dequant shape: +# group size 0 = auto, -1 = row-wise; explicit values snap down to a divisor of in_features +# and grouped weights force a per-forward re-quantize when quantized matmul is on +group_sweep_dtypes = ["int8", "uint4"] +group_sweep_values = [0, -1, 32, 64, 128, 256] +svd_rank_sweep_dtypes = ["int8", "uint4"] +svd_rank_sweep_values = [16, 32, 64, 128] +hadamard_group_values = [32, 64, 128, 256] # weight-side rotation group, swept on int8 +toggle_dtypes = ["int8", "uint4"] # dequantize using full precision off is measured on these +dynamic_quant_requests = ["uint2", "uint4", "int6"] # dynamic quantization escalates until loss passes +# conv geometry: sdxl unet mid-block and vae decoder convs, the two conv-heavy model classes +conv_shapes = [ + ("unet 1280x1280 3x3 @32px", 1280, 1280, 3, 32), + ("vae 512x512 3x3 @256px", 512, 512, 3, 256), +] +conv_configs = [ # id, weights config (None = bf16 baseline), use conv quantized matmul + ("bf16", None, False), + ("int8", dict(weights_dtype="int8"), False), + ("int8-mm", dict(weights_dtype="int8"), True), + ("uint8-mm", dict(weights_dtype="uint8"), True), +] +all_dequant_sweeps = ["groups", "svd", "hgroups", "toggles", "conv"] +all_mm_backends = ["torch", "triton"] +recommend_error_cap = 2.0 # a faster config is not recommended when it multiplies measured output error beyond this + +atten_settings = [ + ("sdnq_attention_use_quantized_matmul", "Use Quantized MatMul"), + ("sdnq_attention_matmul_type", "MatMul type"), + ("sdnq_attention_pv_matmul_type", "PV MatMul type"), + ("sdnq_attention_smooth_k", "Use Smooth K"), + ("sdnq_attention_use_hadamard", "Use Hadamard"), + ("sdnq_attention_hadamard_group_size", "Hadamard Group Size"), +] + + +def parse_cli(): + parser = argparse.ArgumentParser(description="benchmark and validate sdnq attention and weight dequantization on the local gpu") + parser.add_argument("--sections", type=str, default=",".join(all_sections), help=f"comma-separated benchmark sections: {', '.join(all_sections)} (default: %(default)s)") + parser.add_argument("--dequant-dtypes", type=str, default="all", help=f"comma-separated dequant dtype configs: {', '.join(dtype_id for dtype_id, _label, _cfg in dequant_dtype_configs)}; 'all' runs every one (default: %(default)s)") + parser.add_argument("--dequant-variants", type=str, default="all", help=f"comma-separated svd/hadamard variants benched on {', '.join(dequant_variant_dtypes)}: {', '.join(variant_id for variant_id, _cfg in dequant_variant_configs)}; 'all' or 'none' (default: %(default)s)") + parser.add_argument("--dequant-sweeps", type=str, default="all", help=f"comma-separated setting sweeps in the dequant section: {', '.join(all_dequant_sweeps)}; 'all' or 'none' (default: %(default)s)") + parser.add_argument("--mm-backends", type=str, default="none", help=f"comma-separated quantized-matmul backends to compare in one run: {', '.join(all_mm_backends)}; 'none' benches only the backend this device selects (default: %(default)s)") + parser.add_argument("--mm-rounds", type=int, default=2, help="alternating rounds per matmul backend, fastest kept, so clock drift cancels instead of favouring one backend (default: %(default)s)") + parser.add_argument("--block-configs", type=str, default="all", help=f"comma-separated combined block configs: {', '.join(config_id for config_id, _w, _mm, _a in block_configs)}; 'all' runs every one (default: %(default)s)") + parser.add_argument("--shapes", type=str, default=default_shapes, help=f"comma-separated attention shape presets: {', '.join(shape_presets)}; 'all' runs {', '.join(full_run)} (default: %(default)s)") + parser.add_argument("--iters", type=int, default=12, help="minimum timed iterations per config, scaled up for fast kernels (default: %(default)s)") + parser.add_argument("--warmup", type=int, default=4, help="minimum warmup iterations per config, scaled up for fast kernels (default: %(default)s)") + parser.add_argument("--skip-checks", action="store_true", help="skip kernel correctness checks") + parser.add_argument("--skip-bench", action="store_true", help="skip benchmarks, run checks and the fp8 and compile probes only") + parser.add_argument("--dtype", type=str, default="auto", choices=["auto", "bf16", "fp16"], help="tensor dtype for benchmarks; auto uses the dtype the webui selected for this gpu (default: %(default)s)") + parser.add_argument("--config-timeout", type=int, default=300, help="best effort: abort a config whose compile plus first call exceeds this many seconds, 0 disables; cannot interrupt native-level hangs (default: %(default)s)") + parser.add_argument("--save", type=str, default=None, help="write a plain-text copy of all tables and notes to this file; keeps colors and live progress on the terminal, unlike piping through tee") + parser.add_argument("--json", type=str, default=None, help="write structured results (environment, probes, per-shape and dequant timings, recommendations) to this file") + args = parser.parse_args() + sys.argv = sys.argv[:1] # sdnext parses argv again on import and rejects unknown arguments + return args + + +def package_version(name): + try: + return importlib.metadata.version(name) + except Exception: + return None + + +def triton_version(): + # distribution name varies by platform (triton-windows, pytorch-triton-rocm); report the module version + try: + import triton + return triton.__version__ + except Exception: + return None + + +@contextmanager +def suppress_console_output(): + # gate stdout and stderr at the fd level: covers python loggers regardless of their + # handler plumbing plus native-code writes (onnxruntime device discovery on wsl) + saved_stdout, saved_stderr = os.dup(1), os.dup(2) + devnull = os.open(os.devnull, os.O_WRONLY) + try: + sys.stdout.flush() + sys.stderr.flush() + os.dup2(devnull, 1) + os.dup2(devnull, 2) + yield + finally: + sys.stdout.flush() + sys.stderr.flush() + os.dup2(saved_stdout, 1) + os.dup2(saved_stderr, 2) + os.close(devnull) + os.close(saved_stdout) + os.close(saved_stderr) + + +def load_sdnext(): + global shared, devices, sdnq_triton_atten # pylint: disable=global-statement + root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + if root not in sys.path: + sys.path.insert(0, root) + if not torch_device_module.is_available(): + console.print("[red]no cuda, rocm or xpu device available: sdnq attention requires a gpu with triton[/red]") + return False + stock_sdpa = torch.nn.functional.scaled_dot_product_attention + # the webui startup log (device detect, packages, settings validation) is noise here: the + # environment panel reports the stack. the bootstrap reconfigures its loggers during + # import and onnxruntime's device discovery warns from c++, so gate the os-level fds for + # the import window; failures still surface as exceptions printed after the gate lifts + os.environ.setdefault("TRANSFORMERS_VERBOSITY", "error") + try: + with suppress_console_output(): + from modules import shared as shared_module + from modules import devices as devices_module + from modules.sdnq.kernels.triton_atten import sdnq_triton_atten as atten + except Exception as e: + console.print(f"[red]failed to import the sdnq attention kernel: {e}[/red]") + console.print("run from the sdnext root with the venv active; triton is required") + return False + # keep the sdnext loggers quiet after the bootstrap too, so stray log lines cannot tear + # the live tables mid-bench + try: + import installer + installer.log.setLevel(logging.CRITICAL) + from modules.logger import log as sdnext_log + sdnext_log.setLevel(logging.CRITICAL) + except Exception: + pass + # importing modules.shared installs the configured sdp override hijacks in this process; + # restore stock sdpa so baselines and references measure torch itself + torch.nn.functional.scaled_dot_product_attention = stock_sdpa + shared = shared_module + devices = devices_module + sdnq_triton_atten = atten + # inductor dumps failing buffers at CRITICAL to raw stderr, tearing the live + # display; failures still surface as exceptions in the tables + logging.getLogger("torch._inductor").setLevel(logging.CRITICAL + 1) + return True + + +def sage_attention(): + # mirror the backend selection from modules/attention.py: sm86 needs the cuda backend + try: + if torch_device_module.get_device_capability(torch.device(torch_device)) == (8, 6): + from sageattention import sageattn_qk_int8_pv_fp16_cuda + def sage_fn(q, k, v, scale): + return sageattn_qk_int8_pv_fp16_cuda(q=q, k=k, v=v, tensor_layout="HND", is_causal=False, sm_scale=scale, return_lse=False, pv_accum_dtype="fp32") + else: + from sageattention import sageattn + def sage_fn(q, k, v, scale): + return sageattn(q=q, k=k, v=v, attn_mask=None, dropout_p=0.0, is_causal=False, scale=scale) + return sage_fn + except Exception: + return None + + +def amd_triton_flash(): + # sdnext's vendored flash attention for rocm/zluda (modules/flash_attn_triton_amd): the + # relevant baseline on amd, where stock sdpa has no flash kernel and sage is unavailable + try: + if getattr(devices, "backend", None) not in {"rocm", "zluda"}: + return None + from modules.flash_attn_triton_amd import interface_fa + def flash_fn(q, k, v, scale, is_causal=False): + head_size = q.size(3) + if head_size % 8 != 0: + pad = 8 - head_size % 8 + q = torch.nn.functional.pad(q, [0, pad]) + k = torch.nn.functional.pad(k, [0, pad]) + v = torch.nn.functional.pad(v, [0, pad]) + q, k, v = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2) + out = torch.zeros_like(q) + interface_fa.fwd(q, k, v, out, 0.0, scale, is_causal) + return out[..., :head_size].transpose(1, 2) + return flash_fn + except Exception: + return None + + +def sage_attention_fp16_accum(): + # sage's fast sm86 mode: fp16 pv accumulation, which sdnext deliberately does not ship + # (accumulator overflow risk on extreme activations); benched to quantify what that + # choice costs in speed and buys in error + try: + if torch_device_module.get_device_capability(torch.device(torch_device)) != (8, 6): + return None + from sageattention import sageattn_qk_int8_pv_fp16_cuda + def sage_fn(q, k, v, scale): + return sageattn_qk_int8_pv_fp16_cuda(q=q, k=k, v=v, tensor_layout="HND", is_causal=False, sm_scale=scale, return_lse=False, pv_accum_dtype="fp16") + return sage_fn + except Exception: + return None + + +def make_qkv(batch, heads, tokens, head_dim, structured=True, kv_heads=None, kv_tokens=None): + # structured keys carry a shared per-channel bias plus a few outlier channels, mimicking the + # key statistics that motivate smoothing and rotation; absolute error varies by model + # architecture while the relative ordering of configs holds + generator = torch.Generator(device=torch_device).manual_seed(1234) + kv_heads = kv_heads or heads + kv_tokens = kv_tokens or tokens + q = torch.randn(batch, heads, tokens, head_dim, device=torch_device, dtype=bench_dtype, generator=generator) + k = torch.randn(batch, kv_heads, kv_tokens, head_dim, device=torch_device, dtype=bench_dtype, generator=generator) + v = torch.randn(batch, kv_heads, kv_tokens, head_dim, device=torch_device, dtype=bench_dtype, generator=generator) + if structured: + k = k + torch.randn(1, kv_heads, 1, head_dim, device=torch_device, dtype=bench_dtype, generator=generator) * 3.0 + k[..., [3, head_dim // 2, head_dim - 5]] *= 4.0 + return q, k, v + + +def fp32_reference(q, k, v, **kwargs): + # sdnext enables tf32 globally; a math-backend dispatch fallback would degrade the reference to tf32 precision + tf32_matmul = torch.backends.cuda.matmul.allow_tf32 + tf32_cudnn = torch.backends.cudnn.allow_tf32 + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + try: + return torch.nn.functional.scaled_dot_product_attention(q.to(torch.float32), k.to(torch.float32), v.to(torch.float32), **kwargs) + finally: + torch.backends.cuda.matmul.allow_tf32 = tf32_matmul + torch.backends.cudnn.allow_tf32 = tf32_cudnn + + +def rel_err(out, ref): + out = out.to(torch.float32) + return ((out - ref).norm() / ref.norm()).item() + + +def max_token_err(out, ref, eps=1e-6): + # worst single-token relative error over the feature axis: catches localized corruption + # (one garbage image region, one dead token) that a global norm averages away + out = out.to(torch.float32) + numerator = (out - ref).norm(dim=-1) + denominator = ref.norm(dim=-1).clamp_min(eps) + return (numerator / denominator).max().item() + + +def err_cell(value, fmt="{:.5f}"): + # non-finite outputs are the black-image failure class; label them instead of printing nan + if value is None: + return "-" + if not math.isfinite(value): + return "[red]non-finite[/red]" + return fmt.format(value) + + +def fp32_linear_reference(x, weight_fp32): + # sdnext enables tf32 globally; compute the linear reference in true fp32, matching fp32_reference + tf32_matmul = torch.backends.cuda.matmul.allow_tf32 + torch.backends.cuda.matmul.allow_tf32 = False + try: + return torch.nn.functional.linear(x.to(torch.float32), weight_fp32) + finally: + torch.backends.cuda.matmul.allow_tf32 = tf32_matmul + + +def cuda_context_alive(): + # a kernel fault (misaligned address, illegal memory access) is sticky: every later cuda + # call in the process fails; detect it so sections abort cleanly instead of cascading + try: + torch.zeros(1, device=torch_device) + torch_device_module.synchronize() + return True + except Exception: + return False + + +def error_summary(e, limit=60): + # dynamo appends advice lines ("Set TORCHDYNAMO_VERBOSE=1 ...") after the real error; + # keep the last substantive line so table rows show the actual failure + lines = [line.strip() for line in str(e).splitlines()] + lines = [line for line in lines if line and "TORCHDYNAMO_VERBOSE" not in line and "TORCH_LOGS" not in line] + text = lines[-1] if lines else type(e).__name__ + return text[:limit] + + +compile_error_markers = ("InductorError", "BackendCompilerFailed", "CompilationError", "TritonError") + + +def failure_text(e): + # label known compile failures plainly, technical detail dimmed + detail = error_summary(e) + if isinstance(e, TimeoutError): + return f"[red]failed: compile timed out[/red] [dim]({detail})[/dim]" + if type(e).__name__ in compile_error_markers or any(marker in str(e) for marker in compile_error_markers): + return f"[red]failed: torch compile error[/red] [dim]({detail})[/dim]" + return f"[red]{type(e).__name__}[/red]: {detail}" + + +def speedup_cell(base_ms, ms): + ratio = base_ms / ms + text = f"x{ratio:4.2f}" + if ratio >= 1.10: + return f"[green]{text}[/green]" + if ratio < 0.95: + return f"[red]{text}[/red]" + return text + + +def live_progress(): + # status line shown under a live-filling table + progress = Progress(SpinnerColumn(), TextColumn("{task.description}"), TimeElapsedColumn(), console=console) + task = progress.add_task("starting", total=None) + return progress, task + + +@contextmanager +def time_limit(seconds, label): + # torch.compile can spin indefinitely in sympy/inductor on pathological graphs + # (e.g. hadamard over a padded non pow2 head dim); turn a wedged compile into a red row + if seconds <= 0 or not hasattr(signal, "SIGALRM"): + yield + return + def handler(signum, frame): # pylint: disable=unused-argument + raise TimeoutError(f"{label}: compile plus first call exceeded {seconds}s") + previous = signal.signal(signal.SIGALRM, handler) + signal.alarm(seconds) + try: + yield + finally: + signal.alarm(0) + signal.signal(signal.SIGALRM, previous) + + +def bench(fn, warmup, iters, on_phase=None): + if on_phase: + on_phase("warmup") + fn() + torch_device_module.synchronize() + started = time.perf_counter() + fn() + torch_device_module.synchronize() + estimate = max(time.perf_counter() - started, 1e-6) + # scale counts to a time budget so short kernels get enough activity to ramp gpu clocks + warmup = min(max(warmup, int(0.2 / estimate)), 500) + iters = min(max(iters, int(0.5 / estimate)), 500) + for _ in range(warmup): + fn() + torch_device_module.synchronize() + if on_phase: + on_phase(f"timing {iters} iterations") + events = [(torch_device_module.Event(enable_timing=True), torch_device_module.Event(enable_timing=True)) for _ in range(iters)] + for start, end in events: + start.record() + fn() + end.record() + torch_device_module.synchronize() + times = sorted(start.elapsed_time(end) for start, end in events) + return times[len(times) // 2] + + +def free_vram_gb(): + free, _total = torch_device_module.mem_get_info() + return free / 1024**3 + + +def fp8_compile_gate_flag(): + # present and False on sdnq builds that gate fp8 storage weights to eager dequant on + # gpus where triton cannot compile e4m3; absent on builds without the gate + try: + from modules.sdnq import kernel_wrappers as sdnq_kernel_wrappers + return getattr(sdnq_kernel_wrappers, "is_fp8_compile_supported", None) + except Exception: + return None + + +def fp8_failure_is_capability(detail): + # the triton pre-sm_89 signature; anything else is an environment failure where a torch + # or triton issue is more likely than a missing hardware capability + detail = detail or "" + return "fp8e4nv" in detail or "not supported in this architecture" in detail + + +def print_environment(fp8_result, prep_status, prep_detail, weight_dequant_result=None): + device = torch.device(torch_device) + capability = torch_device_module.get_device_capability(device) + # backend runtime versions (cuda/cudnn/driver, hip, ipex, openvino, directml) so a shared + # report identifies the stack without inferring it from the torch version string + try: + gpu_info = devices.get_gpu_info() or {} + except Exception: + gpu_info = {} + runtime_versions = {key: gpu_info[key] for key in ("cuda", "hip", "cudnn", "driver", "ipex", "openvino", "directml") if gpu_info.get(key)} + runtime_line = f"python: {sys.version.split()[0]} ({sys.platform}) backend: {getattr(devices, 'backend', 'unknown')}" + if runtime_versions: + runtime_line += " " + " ".join(f"{key}: {value}" for key, value in runtime_versions.items()) + lines = [ + f"device: [cyan]{torch_device_module.get_device_name(device)}[/cyan] capability={capability}", + f"torch: {torch.__version__} triton: {triton_version() or 'not installed'} sageattention: {package_version('sageattention') or 'not installed'} flash-attn: {package_version('flash-attn') or 'not installed'}", + runtime_line, + f"benchmark dtype: {dtype_label()}", + ] + if fp8_result is not None: + if fp8_result["qk"][0]: + lines.append("float8_e4m3fn matmul: [green]supported[/green]") + elif fp8_failure_is_capability(fp8_result["qk"][1]): + lines.append(f"float8_e4m3fn matmul: [red]not supported on this gpu, selecting it fails generation[/red] [dim]({escape(fp8_result['qk'][1])})[/dim]") + else: + lines.append(f"float8_e4m3fn matmul: [red]failed to compile in this environment, selecting it fails generation[/red]; the error is not the hardware-capability signature, a torch or triton issue is more likely than the gpu [dim]({escape(fp8_result['qk'][1])})[/dim]") + lines.append(f"sdnq attention enabled in current config: {'[green]yes[/green]' if 'SDNQ attention' in shared.opts.sdp_overrides else '[yellow]no, enable via Compute Settings -> SDP overrides (requires restart)[/yellow]'}") + if prep_status == "disabled": + lines.append("compiled input prep: torch.compile disabled in config, input prep runs eager") + elif prep_status == "working": + lines.append("compiled input prep: [green]working[/green]") + else: + lines.append(f"compiled input prep: [red]failing, every sdnq attention call errors at generation[/red] [dim]({escape(prep_detail)})[/dim]") + if prep_status == "failing_dynamic": + lines.append(" fix, verified on this machine: set SDNQ_COMPILE_KWARGS='{\"dynamic\": false}' (recompiles per shape); or install msvc build tools; or disable Compute Settings -> SDNQ -> Dequantize using torch.compile") + else: + lines.append(" fix: install a host c++ compiler (msvc build tools on windows), or disable Compute Settings -> SDNQ -> Dequantize using torch.compile") + if weight_dequant_result is not None: + gate_flag = fp8_compile_gate_flag() + e4m3_ok, e4m3_detail = weight_dequant_result["float8_e4m3fn"] + e5m2_ok, e5m2_detail = weight_dequant_result["float8_e5m2"] + if e4m3_ok: + lines.append("compiled weight dequant, float8_e4m3fn storage: [green]supported[/green]") + else: + lines.append(f"compiled weight dequant, float8_e4m3fn storage: [red]fails on this gpu[/red] [dim]({escape(e4m3_detail)})[/dim]") + if gate_flag is False: + lines.append(" this sdnq build gates fp8 storage weights to eager dequant, generation is safe (SDNQ_ALLOW_FP8_COMPILE overrides)") + elif gate_flag is None: + lines.append(" [red]this sdnq build has no fp8 compile gate: loading fp8 storage weights with Dequantize using torch.compile enabled fails at generation[/red]") + e5m2_verdict = "[green]supported[/green]" if e5m2_ok else f"[red]fails[/red] [dim]({escape(e5m2_detail)})[/dim]" + lines.append(f"compiled weight dequant, float8_e5m2 storage: {e5m2_verdict}") + overrides = [f"{key}={value}" for key, value in os.environ.items() if key.startswith("SDNQ_TRITON_ATTEN") or key.startswith("SDNQ_ALLOW_FP8") or key.startswith("SDNQ_COMPILE")] + if overrides: + lines.append(f"env overrides: {' '.join(overrides)}") + emit(Panel("\n".join(lines), title="environment", box=ROUNDED_BOX)) + report["environment"] = dict( + device=torch_device_module.get_device_name(device), + capability=f"{capability[0]}.{capability[1]}", + python=sys.version.split()[0], + platform=sys.platform, + backend=str(getattr(devices, "backend", None)), + torch=str(torch.__version__), + triton=triton_version(), + sageattention=package_version("sageattention"), + dtype=dtype_label(), + **runtime_versions, + fp8_attention_matmul=fp8_result["qk"][0] if fp8_result is not None else None, + compiled_input_prep=prep_status, + fp8_compile_gate=fp8_compile_gate_flag(), + weight_dequant_compile={name: dict(ok=ok, detail=detail) for name, (ok, detail) in (weight_dequant_result or {}).items()}, + ) + + +def print_banner(selected, sections, args): + lines = [ + "measures sdnq attention and weight dequantization speed and accuracy on this gpu and recommends values for [cyan]Compute Settings -> SDNQ / SDNQ Attention[/cyan]", + f"sections: [cyan]{', '.join(sections)}[/cyan]", + ] + if args.skip_bench: + lines.append("running correctness checks and the float8 and compile probes only (--skip-bench)") + elif "attention" in sections: + lines.append(f"attention shapes: [cyan]{', '.join(selected)}[/cyan] (available: {', '.join(shape_presets)}; pass --shapes to match the models you use)") + lines.append("first run compiles triton kernels per shape and can take several minutes; repeat runs are much faster") + if args.mm_backends.strip().lower() not in {"none", ""} and "dequant" in sections: + lines.append(f"matmul backends compared in one run: [cyan]{args.mm_backends}[/cyan] (swapped in-process, {args.mm_rounds} alternating rounds per dtype)") + if args.save: + lines.append(f"a plain-text copy of the results will be saved to [cyan]{args.save}[/cyan]") + if args.json: + lines.append(f"structured results will be saved to [cyan]{args.json}[/cyan]") + console.print(Panel("\n".join(lines), title="sdnq benchmark", box=ROUNDED_BOX)) + + +def probe_fp8(): + # hardware probe, prep runs eager via the module-global swap so the verdict isolates the + # attention kernel: fp8 kernel compile fails on pre-ada nvidia and pre-rdna4/cdna3 amd; + # prep failures are dtype-independent and probed separately. do not force eager by + # toggling torch._dynamo.config.disable: torch 2.13+ raises "found no compiled frames" + # for fullgraph-compiled functions called inside a disable window + try: + from modules.sdnq import kernel_wrappers as sdnq_kernel_wrappers + is_fp8_mm_supported = getattr(sdnq_kernel_wrappers, "is_fp8_mm_supported", True) + except Exception: + is_fp8_mm_supported = True + if not is_fp8_mm_supported: + return dict(qk=(False, "FP8 matmul is not supported in this architecture"), pv=(False, "FP8 matmul is not supported in this architecture")) + from modules.sdnq.kernels import triton_atten as atten_module + q, k, v = make_qkv(1, 2, 256, 64, structured=False) + result = {} + compiled_prep = atten_module.get_attn_inputs + inner_prep = getattr(compiled_prep, "_torchdynamo_orig_callable", None) + if inner_prep is not None: + atten_module.get_attn_inputs = inner_prep + try: + with console.status("probing float8 support") as status: + for name, kwargs in [("qk", dict(matmul_dtype="float8_e4m3fn", pv_matmul_dtype="auto")), ("pv", dict(matmul_dtype="auto", pv_matmul_dtype="float8_e4m3fn"))]: + status.update(f"probing float8 support: {name} matmul (a compile failure here is normal on older gpus)") + try: + out = sdnq_triton_atten(q, k, v, **kwargs) + torch_device_module.synchronize() + result[name] = (not bool(torch.isnan(out).any().item()), "compiles and runs") + except Exception as e: + result[name] = (False, f"{type(e).__name__}: {error_summary(e, 120)}") + finally: + atten_module.get_attn_inputs = compiled_prep + return result + + +def probe_compiled_prep(): + # inductor lowers part of the dynamic-shape prep to a cpu helper kernel, so a missing + # host c++ compiler (msvc on windows) fails every sdnq attention call at generation. + # must run before any other sdnq_triton_atten call: a prior eager run masks the + # cold-start failure the webui hits + if not shared.opts.sdnq_dequantize_compile: + return "disabled", None + q, k, v = make_qkv(1, 2, 256, 64, structured=False) + with console.status("probing compiled input prep (compiles on first run, cached afterwards)"): + try: + sdnq_triton_atten(q, k, v, matmul_dtype="auto", pv_matmul_dtype="auto") + torch_device_module.synchronize() + return "working", None + except Exception as e: + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + detail = f"{type(e).__name__}: {error_summary(e, 120)}" + # check whether the dynamic=false workaround holds + from modules.sdnq.kernels import triton_atten as atten_module + compiled_prep = atten_module.get_attn_inputs + inner = getattr(compiled_prep, "_torchdynamo_orig_callable", None) + if inner is None: + return "failing", detail + static_ok = False + with console.status("compiled input prep failed, verifying the dynamic=false workaround"): + atten_module.get_attn_inputs = torch.compile(inner, fullgraph=True, dynamic=False) + try: + sdnq_triton_atten(q, k, v, matmul_dtype="auto", pv_matmul_dtype="auto") + torch_device_module.synchronize() + static_ok = True + except Exception: + pass + finally: + atten_module.get_attn_inputs = compiled_prep + torch._dynamo.reset() # pylint: disable=protected-access + return ("failing_dynamic" if static_ok else "failing"), detail + + +def make_source_weight(out_features, in_features, seed=1234): + # structured weights with a few high-magnitude input channels, mimicking the outlier + # statistics of real dit linears; keeps quantization error columns in a realistic range + generator = torch.Generator(device=torch_device).manual_seed(seed) + weight = torch.randn(out_features, in_features, device=torch_device, dtype=bench_dtype, generator=generator) * 0.02 + weight[:, [3, in_features // 2, in_features - 5]] *= 8.0 + return weight + + +class BenchBlock(torch.nn.Module): + # dit-style block: fused qkv self-attention plus a gelu mlp, both with residuals; the + # attention_fn attribute is set per benchmark config (stock sdpa or sdnq attention) + def __init__(self, hidden, heads, mlp_dim, device=None, dtype=None): + super().__init__() + self.heads = heads + self.norm1 = torch.nn.LayerNorm(hidden, elementwise_affine=False, device=device, dtype=dtype) + self.norm2 = torch.nn.LayerNorm(hidden, elementwise_affine=False, device=device, dtype=dtype) + self.qkv = torch.nn.Linear(hidden, hidden * 3, bias=False, device=device, dtype=dtype) + self.proj = torch.nn.Linear(hidden, hidden, bias=False, device=device, dtype=dtype) + self.up = torch.nn.Linear(hidden, mlp_dim, bias=False, device=device, dtype=dtype) + self.down = torch.nn.Linear(mlp_dim, hidden, bias=False, device=device, dtype=dtype) + self.attention_fn = None + + def forward(self, x): + batch, tokens, channels = x.shape + h = self.norm1(x) + qkv = self.qkv(h).view(batch, tokens, 3, self.heads, channels // self.heads).permute(2, 0, 3, 1, 4) + attn = self.attention_fn(qkv[0], qkv[1], qkv[2]).transpose(1, 2).reshape(batch, tokens, channels) + x = x + self.proj(attn) + h = self.norm2(x) + return x + self.down(torch.nn.functional.gelu(self.up(h))) + + +def make_block_master(): + # one master weight set shared by every block config, so all rows quantize identical weights + hidden, heads, mlp_dim = block_geometry["hidden"], block_geometry["heads"], block_geometry["mlp_dim"] + block = BenchBlock(hidden, heads, mlp_dim, device=torch_device, dtype=bench_dtype) + with torch.no_grad(): + for seed, linear in enumerate((block.qkv, block.proj, block.up, block.down), start=1): + linear.weight.copy_(make_source_weight(linear.out_features, linear.in_features, seed=seed)) + return {key: value.clone() for key, value in block.state_dict().items()} + + +def build_bench_block(master_sd, weights_cfg, use_mm, attention_spec): + from modules.sdnq import SDNQConfig + from modules.sdnq.quantizer import apply_sdnq_to_module + hidden, heads, mlp_dim = block_geometry["hidden"], block_geometry["heads"], block_geometry["mlp_dim"] + block = BenchBlock(hidden, heads, mlp_dim, device=torch_device, dtype=bench_dtype) + block.load_state_dict(master_sd) + block.eval() + for param in block.parameters(): + param.requires_grad_(False) + if weights_cfg is not None: + config = SDNQConfig(use_quantized_matmul=use_mm, add_skip_keys=False, **weights_cfg) + block, _config = apply_sdnq_to_module(block, config, torch_dtype=bench_dtype) + atten_kwargs = block_attention_specs[attention_spec] + if atten_kwargs is None: + def attention_fn(q, k, v): + return torch.nn.functional.scaled_dot_product_attention(q, k, v) + elif isinstance(atten_kwargs, str): + sage_fn = sage_attention() if atten_kwargs == "sage" else sage_attention_fp16_accum() + if sage_fn is None: + raise RuntimeError("sageattention unavailable") + def attention_fn(q, k, v, fn=sage_fn): + return fn(q, k, v, q.shape[-1] ** -0.5) + else: + def attention_fn(q, k, v, kw=atten_kwargs): + return sdnq_triton_atten(q, k, v, **kw) + block.attention_fn = attention_fn + return block + + +def block_storage_bytes(block): + total = 0 + for module in block.modules(): + if hasattr(module, "sdnq_dequantizer"): + total += layer_storage_bytes(module) + elif isinstance(module, torch.nn.Linear): + total += module.weight.numel() * module.weight.element_size() + return total + + +def make_quantized_linear(weight, weights_dtype, group_size=0, use_quantized_matmul=False, use_svd=False, use_hadamard=False, quantized_matmul_dtype=None, device=torch_device, **config_kwargs): + # quantize through the same entry point model loading uses, so forward benches measure + # the production wrapper classes and dequantizer configuration; returns the quantize wall + # time, a one-shot measurement of what on-the-fly quantization pays per layer at load + from modules.sdnq import SDNQConfig + from modules.sdnq.quantizer import sdnq_quantize_layer + out_features, in_features = weight.shape + linear = torch.nn.Linear(in_features, out_features, bias=False, device=device, dtype=bench_dtype) + with torch.no_grad(): + linear.weight.copy_(weight) + config = SDNQConfig(weights_dtype=weights_dtype, group_size=group_size, use_quantized_matmul=use_quantized_matmul, use_svd=use_svd, use_hadamard=use_hadamard, quantized_matmul_dtype=quantized_matmul_dtype, add_skip_keys=False, **config_kwargs) + torch_device_module.synchronize() + started = time.perf_counter() + layer, _config = sdnq_quantize_layer(linear, config, torch_dtype=bench_dtype, param_name="bench.weight") + torch_device_module.synchronize() + quant_seconds = time.perf_counter() - started + if not hasattr(layer, "sdnq_dequantizer"): + raise RuntimeError(f"sdnq did not quantize the layer to {weights_dtype}") + return layer, quant_seconds + + +def layer_storage_bytes(layer): + # measured storage of everything the quantized layer keeps: packed weights, scales, + # zero points and svd factors; sizes on disk and in vram follow this, not the nominal bits + total = 0 + for name in ("weight", "scale", "zero_point", "svd_up", "svd_down"): + tensor = getattr(layer, name, None) + if isinstance(tensor, (torch.Tensor, torch.nn.Parameter)): + total += tensor.numel() * tensor.element_size() + return total + + +def size_cell(size_bytes): + return f"{size_bytes / 1024**2:6.1f}mb" + + +def quant_cell(quant_seconds): + return f"{quant_seconds * 1000.0:5.0f}ms" if quant_seconds is not None else "-" + + +def dequant_args(layer): + # mirror SDNQDequantizer.__call__'s marshaling so the direct compiled call below measures + # the same graph the instance would compile + deq = layer.sdnq_dequantizer + kwargs = dict( + zero_point=getattr(layer, "zero_point", None), + svd_up=getattr(layer, "svd_up", None), + svd_down=getattr(layer, "svd_down", None), + dtype=deq.result_dtype, + result_shape=deq.result_shape, + quantized_weight_shape=deq.quantized_weight_shape, + re_quantize_for_matmul=deq.re_quantize_for_matmul or deq.is_packed, + ) + return (deq.weights_dtype, layer.weight, layer.scale), kwargs + + +def get_compiled_dequantize_weight(): + # sdnq's own dequantize_weight_compiled is a passthrough when the config has Dequantize + # using torch.compile off; compile a tool-owned variant with the same kwargs so compiled + # rows always measure what the webui runs with the option on. sdnq only raises the dynamo + # recompile limits when the option is on; raise them here too or the per-dtype-per-shape + # specializations exceed the default limit of 8 and silently fall back to eager + global compiled_dequantize_weight # pylint: disable=global-statement + if compiled_dequantize_weight is None: + for limit_name in ("recompile_limit", "cache_size_limit", "accumulated_recompile_limit", "accumulated_cache_size_limit"): + if hasattr(torch._dynamo.config, limit_name): # pylint: disable=protected-access + setattr(torch._dynamo.config, limit_name, max(8192, getattr(torch._dynamo.config, limit_name) or 0)) # pylint: disable=protected-access + from modules.sdnq.dequantizer import dequantize_weight + compiled_dequantize_weight = torch.compile(dequantize_weight, fullgraph=True, dynamic=False) + return compiled_dequantize_weight + + +def dequant_gated_to_eager(weights_dtype): + # sdnq builds with the fp8 compile gate route e4m3 storage to eager dequant on gpus + # where triton cannot compile it; report instead of measuring a silently-eager row + try: + from modules.sdnq import dequantizer as dequantizer_module + gate = getattr(dequantizer_module, "skip_fp8_compile", None) + return bool(gate(weights_dtype)) if gate is not None else False + except Exception: + return False + + +def probe_weight_dequant_compile(): + # compiled weight dequantization per fp8 storage dtype: triton before sm_89 lacks e4m3 + # conversions, so compiled dequant of float8_e4m3fn storage crashes on ampere while e5m2 + # is expected to compile; the verdicts show whether this build needs the fp8 compile gate + result = {} + for name in ("float8_e4m3fn", "float8_e5m2"): + with console.status(f"probing compiled weight dequant: {name} storage (a compile failure here is expected for e4m3 on pre-ada nvidia)"): + try: + layer, _quant_seconds = make_quantized_linear(make_source_weight(256, 256), name) + args, kwargs = dequant_args(layer) + out = get_compiled_dequantize_weight()(*args, **kwargs) + torch_device_module.synchronize() + result[name] = (bool(torch.isfinite(out).all().item()), "compiles and runs") + except Exception as e: + result[name] = (False, f"{type(e).__name__}: {error_summary(e, 120)}") + reset_compiled_dequant() # drop failed compile state so later rows compile fresh + return result + + +def reset_compiled_dequant(): + global compiled_dequantize_weight # pylint: disable=global-statement + compiled_dequantize_weight = None + torch._dynamo.reset() # pylint: disable=protected-access + + +def run_correctness(): + checks = [] + q, k, v = make_qkv(2, 8, 512, 64, structured=False) + checks.append(("plain", (q, k, v), {}, {})) + checks.append(("causal", (q, k, v), dict(is_causal=True), {})) + qg, kg, vg = make_qkv(2, 8, 512, 64, structured=False, kv_heads=2) + checks.append(("gqa 8:2 heads", (qg, kg, vg), dict(enable_gqa=True), {})) + bool_mask = torch.zeros(2, 1, 1, 512, device=torch_device, dtype=torch.bool) + bool_mask[..., :384] = True + checks.append(("bool key-padding mask", (q, k, v), dict(attn_mask=bool_mask), {})) + float_mask = torch.zeros(2, 1, 1, 512, device=torch_device, dtype=bench_dtype) + float_mask[..., 384:] = float("-inf") + checks.append(("float additive mask", (q, k, v), dict(attn_mask=float_mask), {})) + checks.append(("smooth k + hadamard", (q, k, v), {}, dict(smooth_k=True, use_hadamard=True))) + checks.append(("smooth + hadamard + int8 pv", (q, k, v), {}, dict(smooth_k=True, use_hadamard=True, pv_matmul_dtype="int8"))) + qp, kp, vp = make_qkv(2, 8, 512, 40, structured=False) + checks.append(("head dim 40 (padded)", (qp, kp, vp), {}, {})) + checks.append(("head dim 40 + hadamard", (qp, kp, vp), {}, dict(use_hadamard=True))) + qn, kn, vn = make_qkv(2, 8, 1000, 64, structured=False) + checks.append(("non-pow2 sequence 1000", (qn, kn, vn), {}, {})) + qx, kx, vx = make_qkv(2, 8, 512, 64, structured=False, kv_tokens=77) + checks.append(("cross-attention 512q 77kv", (qx, kx, vx), {}, {})) + # stress rows model the extreme-activation class (qwen-image, z-image base) where quantized + # attention paths have produced non-finite outputs in the wild; they pass on finite output, + # errors are informational since saturated softmax legitimately degrades accuracy + qs, ks, vs = make_qkv(2, 8, 512, 64, structured=False) + checks.append(("stress: 100x activations", (qs * 100.0, ks * 100.0, vs * 100.0), {}, {})) + ko = ks.clone() + ko[:, :, :2, :] *= 1000.0 + checks.append(("stress: 1000x outlier keys", (qs, ko, vs), {}, {})) + checks.append(("stress: fp16 100x activations", ((qs * 100.0).to(torch.float16), (ks * 100.0).to(torch.float16), (vs * 100.0).to(torch.float16)), {}, {})) + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("code path") + table.add_column("kernel error", justify="right") + table.add_column("int8 error", justify="right") + table.add_column("int8 max token", justify="right") + table.add_column("result", justify="center") + panel = Panel(table, title="kernel correctness", subtitle="[dim]small shapes, vs fp32 sdpa reference; stress rows pass on finite output[/dim]", box=ROUNDED_BOX, expand=False) + failed = [] + details = {} + # checks target kernel behavior, so the input prep runs eager via a module-global swap. + # do not toggle torch._dynamo.config.disable for this: newer torch raises "found no + # compiled frames" when a fullgraph-compiled function is called inside a disable window, + # failing every check and poisoning the first compiled call afterwards + from modules.sdnq.kernels import triton_atten as atten_module + compiled_prep = atten_module.get_attn_inputs + inner_prep = getattr(compiled_prep, "_torchdynamo_orig_callable", None) + if inner_prep is not None: + atten_module.get_attn_inputs = inner_prep + aborted_after = None + progress, task = live_progress() + try: + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + for index, (name, (cq, ck, cv), kwargs, sdnq_kwargs) in enumerate(checks, start=1): + progress.reset(task, description=f"check {index}/{len(checks)} {name}") + try: + ref_kwargs = dict(kwargs) + if ref_kwargs.get("attn_mask", None) is not None and torch.is_floating_point(ref_kwargs["attn_mask"]): + ref_kwargs["attn_mask"] = ref_kwargs["attn_mask"].to(torch.float32) # stock sdpa requires the additive mask dtype to match query + ref = fp32_reference(cq, ck, cv, **ref_kwargs) + plain = sdnq_triton_atten(cq, ck, cv, do_quantize=False, **kwargs) + quant_kwargs = dict(matmul_dtype="auto", pv_matmul_dtype="auto", **kwargs) + quant_kwargs.update(sdnq_kwargs) + quant = sdnq_triton_atten(cq, ck, cv, **quant_kwargs) + err_plain = rel_err(plain, ref) + err_quant = rel_err(quant, ref) + max_err = max_token_err(quant, ref) + finite = bool(torch.isfinite(plain).all().item() and torch.isfinite(quant).all().item()) + if name.startswith("stress:"): + ok = finite + else: + ok = finite and err_plain < 0.01 and err_quant < 0.2 + if not ok: + failed.append(name) + details[name] = dict(kernel_err=err_plain, int8_err=err_quant, max_token_err=max_err, finite=finite, ok=ok) + verdict = "[green]pass[/green]" if ok else "[red]fail[/red]" + if not finite: + verdict = "[red]non-finite[/red]" + table.add_row(name, err_cell(err_plain), err_cell(err_quant), err_cell(max_err), verdict) + except Exception as e: + failed.append(name) + details[name] = dict(error=error_summary(e, 200)) + table.add_row(name, "-", "-", "-", failure_text(e)) + if not cuda_context_alive(): + aborted_after = name + break + live.update(panel) + finally: + atten_module.get_attn_inputs = compiled_prep + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + if aborted_after is not None: + emit(f"[red]the {aborted_after!r} check faulted the gpu and cuda errors are sticky: remaining checks and benchmarks cannot run in this process. rerun with --skip-checks and shapes that avoid the faulting geometry to collect the rest[/red]") + report["correctness_aborted_after"] = aborted_after + if failed: + emit(f"[red]failed checks: {', '.join(failed)}[/red]") + if "head dim 40 + hadamard" in failed and shared.opts.sdnq_attention_use_hadamard: + emit("[yellow]current config has Use Hadamard enabled: models with non power-of-2 head dims (SD 1.5) fail at generation with it[/yellow]") + report["correctness"] = dict(failed=failed, total=len(checks), checks=details) + return failed + + +def make_prep_fn(q, k, v, attn_mask, kwargs, is_causal=False, enable_gqa=False): + # mirror sdnq_triton_atten's prep call so the prep column measures the same code path + from modules.sdnq.kernels import triton_atten as atten_module + from modules.sdnq.quant_utils import get_hadamard, get_hadamard_group_size + from modules.sdnq.utils import next_power_of_2 + matmul_dtype = kwargs.get("matmul_dtype", "int8") + do_quantize = kwargs.get("do_quantize", True) + hadamard_group_size = kwargs.get("hadamard_group_size", 256) + hadamard = None + if kwargs.get("use_hadamard", False) and do_quantize and matmul_dtype not in {None, "none", "no"}: + channel_size = next_power_of_2(min(q.shape[-1], k.shape[-1])) + hadamard_group_size = min(hadamard_group_size, channel_size) + enabled, hadamard_group_size = get_hadamard_group_size(channel_size, hadamard_group_size) + if enabled: + hadamard = get_hadamard(hadamard_group_size, dtype=q.dtype, device=q.device) + def prep(): + return atten_module.get_attn_inputs( # module lookup so the static-compile patch applies + query=q, key=k, value=v, hadamard=hadamard, attn_mask=attn_mask, + dropout_p=0.0, is_causal=is_causal, scale=None, enable_gqa=enable_gqa, + smooth_k=kwargs.get("smooth_k", False), hadamard_group_size=hadamard_group_size, + matmul_dtype=matmul_dtype, pv_matmul_dtype=kwargs.get("pv_matmul_dtype", None), + do_quantize=do_quantize, out_dtype=None, + ) + return prep + + +def bench_shape(preset, iters, warmup, position=None, config_timeout=300, fp8_result=None): + preset_cfg = shape_presets[preset] + batch, heads, tokens, head_dim = preset_cfg["batch"], preset_cfg["heads"], preset_cfg["tokens"], preset_cfg["head_dim"] + kv_tokens = preset_cfg.get("kv_tokens", tokens) + kv_heads = preset_cfg.get("kv_heads", heads) + causal = preset_cfg.get("causal", False) + gqa = kv_heads != heads + description = preset_cfg["desc"] + config_ids = {"wan22": video_config_ids, "wan22-cfg": video_config_ids, "ltx2": video_config_ids, "masked": masked_config_ids, "sd15": sd15_config_ids}.get(preset) + if preset == "sd15": + emit("[yellow]sd15: hadamard configs skipped, compiling hadamard with a non pow2 head dim currently hangs torch inductor[/yellow]") + attn_mask = None + if preset == "masked": + attn_mask = torch.zeros(batch, 1, 1, tokens, device=torch_device, dtype=torch.bool) + attn_mask[..., :int(tokens * 0.75)] = True + sage = sage_attention() + sage_fp16 = sage_attention_fp16_accum() + amd_flash = amd_triton_flash() + selected_configs = [] + for config_id, label, kwargs in bench_configs: + if config_ids is not None and config_id not in config_ids: + continue + if config_id == "sage" and (sage is None or attn_mask is not None or head_dim not in {64, 96, 128} or kv_tokens != tokens or gqa or causal): + continue + if config_id == "sagefp16" and (sage_fp16 is None or attn_mask is not None or head_dim not in {64, 96, 128} or kv_tokens != tokens or gqa or causal): + continue + if config_id == "amdflash" and (amd_flash is None or attn_mask is not None or head_dim > 128 or gqa): + continue + if config_id == "fp8qk" and not (fp8_result and fp8_result["qk"][0]): + continue + if config_id == "fp8pv" and not (fp8_result and fp8_result["pv"][0]): + continue + if config_id == "fp8full" and not (fp8_result and fp8_result["qk"][0] and fp8_result["pv"][0]): + continue + selected_configs.append((config_id, label, kwargs)) + + def make_table(): + shape_table = Table(box=box.SIMPLE_HEAVY) + shape_table.add_column("config") + shape_table.add_column("median time", justify="right") + shape_table.add_column("prep", justify="right") + shape_table.add_column("speedup", justify="right") + shape_table.add_column("error", justify="right") + return shape_table + + geometry = f"batch={batch} heads={heads} tokens={tokens} head_dim={head_dim}" + if kv_tokens != tokens: + geometry += f" kv_tokens={kv_tokens}" + if gqa: + geometry += f" kv_heads={kv_heads}" + if causal: + geometry += " causal" + + def make_panel(content): + return Panel(content, title=f"{preset}: {geometry} {dtype_label()}", subtitle=f"[dim]{description}[/dim]", box=ROUNDED_BOX, expand=False) + + table = make_table() + panel = make_panel(table) + results = {} + rows = [] + base_ms = None + prefix = f"shape {position[0]}/{position[1]} " if position else "" + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + progress.update(task, description=f"{prefix}{preset}: preparing inputs and fp32 reference") + q, k, v = make_qkv(batch, heads, tokens, head_dim, kv_heads=kv_heads, kv_tokens=kv_tokens) + scale = head_dim ** -0.5 + ref = fp32_reference(q, k, v, attn_mask=attn_mask, is_causal=causal, enable_gqa=gqa) + for index, (config_id, label, kwargs) in enumerate(selected_configs, start=1): + def phase(step, current_label=label, current_index=index): + progress.update(task, description=f"{prefix}config {current_index}/{len(selected_configs)} {current_label}: {step}") + if config_id == "base": + def fn(mask=attn_mask): + return torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=mask, is_causal=causal, enable_gqa=gqa) + elif config_id == "sage": + def fn(sm=scale): + return sage(q, k, v, sm) + elif config_id == "sagefp16": + def fn(sm=scale): + return sage_fp16(q, k, v, sm) + elif config_id == "amdflash": + def fn(sm=scale): + return amd_flash(q, k, v, sm, is_causal=causal) + else: + def fn(kw=kwargs, mask=attn_mask): + return sdnq_triton_atten(q, k, v, attn_mask=mask, is_causal=causal, enable_gqa=gqa, **kw) + try: + torch._dynamo.reset() # pylint: disable=protected-access # one compiled input-prep specialization per config, matching how the webui runs a fixed config + progress.reset(task) # restart the elapsed clock so it times the current config + phase("compiling") + with time_limit(config_timeout, label): + err = rel_err(fn(), ref) + ms = bench(fn, warmup, iters, on_phase=phase) + prep_cell = "-" + prep_ms = None + if kwargs is not None: # time the input prep alone; included in the median + try: + phase("timing input prep") + prep_ms = bench(make_prep_fn(q, k, v, attn_mask, kwargs, is_causal=causal, enable_gqa=gqa), warmup, iters) + prep_cell = f"[dim]{prep_ms:8.3f} ms[/dim]" + except Exception: + pass + if base_ms is None: + base_ms = ms + results[config_id] = dict(ms=ms, err=err, prep_ms=prep_ms) + row = (label, f"{ms:8.3f} ms", prep_cell, speedup_cell(base_ms, ms), f"{err:.5f}") + rows.append((config_id, ms, row)) + table.add_row(*row) + except Exception as e: + results[config_id] = dict(ms=None, err=None, prep_ms=None, error=error_summary(e, 200)) + row = (label, "-", "-", "-", failure_text(e)) + rows.append((config_id, None, row)) + table.add_row(*row) + # rebuild the table to star the best sdnq config when it beats the baseline + best_id = best_config(results) + if base_ms and best_id is not None and results[best_id]["ms"] < base_ms: + table = make_table() + for config_id, _ms, row in rows: + if config_id == best_id: + table.add_row(f"* {row[0]}", *row[1:], style="bold") # ascii marker: legacy windows consoles crash rendering non-cp1252 characters + else: + table.add_row(*row) + panel = make_panel(table) + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + report.setdefault("attention", {})[preset] = dict(geometry=geometry, results=results) + return results + + +def bench_dequant_shape(shape_label, out_features, in_features, iters, warmup, position=None, config_timeout=300, selected_dtypes=None): + from modules.sdnq.common import check_torch_compile + compile_on = check_torch_compile() + dtype_configs = [(dtype_id, label, cfg) for dtype_id, label, cfg in dequant_dtype_configs if selected_dtypes is None or dtype_id in selected_dtypes] + + def make_table(): + shape_table = Table(box=box.SIMPLE_HEAVY) + shape_table.add_column("config") + shape_table.add_column("quant", justify="right") + shape_table.add_column("size", justify="right") + shape_table.add_column("deq eager", justify="right") + shape_table.add_column("deq compiled", justify="right") + shape_table.add_column("weight err", justify="right") + shape_table.add_column("fwd eager", justify="right") + shape_table.add_column("fwd compiled", justify="right") + shape_table.add_column("quantized mm", justify="right") + shape_table.add_column("mm err", justify="right") + shape_table.add_column("speedup", justify="right") + return shape_table + + def make_panel(content): + subtitle = f"[dim]{dequant_forward_tokens} token input, bias-free linears, errors vs fp32; quantized mm and speedup follow the current config (compile {'on' if compile_on else 'off'})[/dim]" + return Panel(content, title=f"weight dequant: {shape_label} {dtype_label()}", subtitle=subtitle, box=ROUNDED_BOX, expand=False) + + table = make_table() + panel = make_panel(table) + results = {} + notes = [] + prefix = f"shape {position[0]}/{position[1]} " if position else "" + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + progress.update(task, description=f"{prefix}{shape_label}: preparing weights and bf16 baseline") + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(dequant_forward_tokens, in_features, device=torch_device, dtype=bench_dtype, generator=generator) + baseline = torch.nn.Linear(in_features, out_features, bias=False, device=torch_device, dtype=bench_dtype) + with torch.no_grad(): + baseline.weight.copy_(weight) + + def baseline_fn(): + return baseline(x) + + ref_out = fp32_linear_reference(x, weight_fp32) + base_ms = bench(baseline_fn, warmup, iters) + base_err = rel_err(baseline_fn(), ref_out) + base_bytes = baseline.weight.numel() * baseline.weight.element_size() + results["bf16"] = dict(fwd_ms=base_ms, fwd_err=base_err, size_bytes=base_bytes) + table.add_row(f"{dtype_label()} nn.Linear", "-", size_cell(base_bytes), "-", "-", "-", f"{base_ms:8.3f} ms", "-", "-", "-", "x1.00") + + for index, (dtype_id, label, cfg) in enumerate(dtype_configs, start=1): + def phase(step, current_label=label, current_index=index): + progress.update(task, description=f"{prefix}config {current_index}/{len(dtype_configs)} {current_label}: {step}") + entry = dict(eager_ms=None, compiled_ms=None, fwd_eager_ms=None, fwd_compiled_ms=None, fwd_err=None, mm_ms=None, mm_err=None, mm_dtype=None, weight_err=None, quant_s=None, size_bytes=None) + results[dtype_id] = entry + progress.reset(task) + phase("quantizing") + try: + layer, entry["quant_s"] = make_quantized_linear(weight, **cfg) + entry["size_bytes"] = layer_storage_bytes(layer) + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(label, "-", "-", "-", "-", "-", "-", "-", "-", "-", failure_text(e)) + continue + + def eager_fn(current=layer): + return current.sdnq_dequantizer( + current.weight, current.scale, + zero_point=getattr(current, "zero_point", None), + svd_up=getattr(current, "svd_up", None), svd_down=getattr(current, "svd_down", None), + skip_compile=True, + ) + + try: + phase("timing eager dequant") + eager_out = eager_fn().to(torch.float32) + entry["eager_ms"] = bench(eager_fn, warmup, iters) + entry["weight_err"] = rel_err(eager_out, weight_fp32) + eager_cell = f"{entry['eager_ms']:8.3f} ms" + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), failure_text(e), "-", "-", "-", "-", "-", "-", "-") + del layer + continue + + if dequant_gated_to_eager(cfg["weights_dtype"]): + compiled_cell = "[yellow]gated to eager[/yellow]" + entry["compiled_gated"] = True + else: + try: + args, kwargs = dequant_args(layer) + def compiled_fn(current_args=args, current_kwargs=kwargs): + return get_compiled_dequantize_weight()(*current_args, **current_kwargs) + phase("compiling dequant") + with time_limit(config_timeout, label): + compiled_out = compiled_fn() + torch_device_module.synchronize() + entry["compiled_ms"] = bench(compiled_fn, warmup, iters, on_phase=phase) + compiled_cell = f"{entry['compiled_ms']:8.3f} ms" + drift = rel_err(compiled_out, eager_out) + if drift > 1e-3: + notes.append(f"[yellow]{label}: compiled dequant differs from eager by {drift:.2e} relative[/yellow]") + entry["compiled_drift"] = drift + del compiled_out + except Exception as e: + entry["compiled_error"] = error_summary(e, 200) + compiled_cell = failure_text(e) + reset_compiled_dequant() + del eager_out + + def fwd_fn(current=layer): + return current(x) + + # eager-mode forward: the dequantizer's __call__ resolves dequantize_weight_compiled + # as a module global at call time, so pointing it at the eager function for the + # bench matches the webui with Dequantize using torch.compile off. do not toggle + # torch._dynamo.config.disable instead: code objects called during a disable window + # keep their skip marking and never compile again in this process + from modules.sdnq import dequantizer as dequantizer_module + saved_compiled_fn = dequantizer_module.dequantize_weight_compiled + try: + phase("timing linear forward, eager dequant") + dequantizer_module.dequantize_weight_compiled = dequantizer_module.dequantize_weight + fwd_fn() + torch_device_module.synchronize() + entry["fwd_eager_ms"] = bench(fwd_fn, warmup, iters) + entry["fwd_err"] = rel_err(fwd_fn(), ref_out) + fwd_eager_cell = f"{entry['fwd_eager_ms']:8.3f} ms" + except Exception as e: + entry["fwd_eager_error"] = error_summary(e, 200) + fwd_eager_cell = failure_text(e) + finally: + dequantizer_module.dequantize_weight_compiled = saved_compiled_fn + + try: + phase("compiling linear forward") + with time_limit(config_timeout, label): + fwd_fn() + torch_device_module.synchronize() + phase("timing linear forward, compiled dequant") + entry["fwd_compiled_ms"] = bench(fwd_fn, warmup, iters) + fwd_compiled_cell = f"{entry['fwd_compiled_ms']:8.3f} ms" + except Exception as e: + entry["fwd_compiled_error"] = error_summary(e, 200) + fwd_compiled_cell = failure_text(e) + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + del layer + + fwd_ms = entry["fwd_compiled_ms"] if compile_on else entry["fwd_eager_ms"] + entry["fwd_ms"] = fwd_ms # the mode the current config runs; recommendations and speedup key off it + speedup = speedup_cell(base_ms, fwd_ms) if fwd_ms else "-" + + try: + phase("quantizing for quantized matmul") + mm_layer, _mm_quant_seconds = make_quantized_linear(weight, use_quantized_matmul=True, **cfg) + entry["mm_dtype"] = mm_layer.sdnq_dequantizer.quantized_matmul_dtype + def mm_fn(current=mm_layer): + return current(x) + phase("timing quantized matmul forward") + with time_limit(config_timeout, label): + mm_fn() + torch_device_module.synchronize() + entry["mm_ms"] = bench(mm_fn, warmup, iters) + entry["mm_err"] = rel_err(mm_fn(), ref_out) + mm_cell = f"{entry['mm_ms']:8.3f} ms [dim]{entry['mm_dtype']}[/dim]" + del mm_layer + except Exception as e: + entry["mm_error"] = error_summary(e, 200) + mm_cell = failure_text(e) + + if entry["fwd_err"] and entry["weight_err"] and abs(entry["fwd_err"] - entry["weight_err"]) > 0.2 * entry["weight_err"]: + notes.append(f"[yellow]{label}: forward output error {entry['fwd_err']:.5f} diverges from weight error {entry['weight_err']:.5f}[/yellow]") + table.add_row(label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), eager_cell, compiled_cell, err_cell(entry["weight_err"]), fwd_eager_cell, fwd_compiled_cell, mm_cell, err_cell(entry["mm_err"]), speedup) + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + for note in notes: + emit(note) + report.setdefault("dequant", {})[shape_label] = dict(out_features=out_features, in_features=in_features, base_ms=base_ms, results=results) + return results + + +def bench_dequant_variants(shape_label, out_features, in_features, plain_results, selected_dtypes, selected_variants, iters, warmup, config_timeout=300): + # svd and hadamard on top of the base dtypes: the quantize-time, size and error cost of + # each option, benched through the production dequantizer path at one layer shape + variant_configs = [(variant_id, cfg) for variant_id, cfg in dequant_variant_configs if variant_id in selected_variants] + dtype_configs = [(dtype_id, label, cfg) for dtype_id, label, cfg in dequant_dtype_configs if dtype_id in dequant_variant_dtypes and (selected_dtypes is None or dtype_id in selected_dtypes)] + if not variant_configs or not dtype_configs: + return {} + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("config") + table.add_column("quant", justify="right") + table.add_column("size", justify="right") + table.add_column("deq compiled", justify="right") + table.add_column("weight err", justify="right") + table.add_column("err vs plain", justify="right") + table.add_column("fwd compiled", justify="right") + table.add_column("speedup", justify="right") + panel = Panel(table, title=f"svd / hadamard variants: {shape_label} {dtype_label()}", subtitle="[dim]plain rows repeated dimmed for comparison; err vs plain below x1.00 = better reconstruction[/dim]", box=ROUNDED_BOX, expand=False) + + results = {} + base_ms = plain_results.get("bf16", {}).get("fwd_ms") + runs = [(dtype_id, label, cfg, variant_id, variant_cfg) for dtype_id, label, cfg in dtype_configs for variant_id, variant_cfg in variant_configs] + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(dequant_forward_tokens, in_features, device=torch_device, dtype=bench_dtype, generator=generator) + added_plain = set() + for index, (dtype_id, label, cfg, variant_id, variant_cfg) in enumerate(runs, start=1): + row_label = f"{label} + {variant_id}" + def phase(step, current_label=row_label, current_index=index): + progress.update(task, description=f"variant {current_index}/{len(runs)} {current_label}: {step}") + if dtype_id not in added_plain: + added_plain.add(dtype_id) + plain = plain_results.get(dtype_id) or {} + if plain.get("weight_err") is not None: + plain_fwd = plain.get("fwd_compiled_ms") + table.add_row( + f"[dim]{label}[/dim]", f"[dim]{quant_cell(plain.get('quant_s'))}[/dim]", f"[dim]{size_cell(plain['size_bytes'])}[/dim]", + f"[dim]{plain['compiled_ms']:8.3f} ms[/dim]" if plain.get("compiled_ms") else "-", + f"[dim]{plain['weight_err']:.5f}[/dim]", "[dim]x1.00[/dim]", + f"[dim]{plain_fwd:8.3f} ms[/dim]" if plain_fwd else "-", + f"[dim]{speedup_cell(base_ms, plain_fwd)}[/dim]" if base_ms and plain_fwd else "-", + ) + entry = dict(quant_s=None, size_bytes=None, compiled_ms=None, weight_err=None, err_ratio=None, fwd_ms=None) + results[f"{dtype_id}+{variant_id}"] = entry + progress.reset(task) + phase("quantizing") + try: + layer, entry["quant_s"] = make_quantized_linear(weight, **cfg, **variant_cfg) + entry["size_bytes"] = layer_storage_bytes(layer) + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, "-", "-", "-", "-", "-", "-", failure_text(e)) + continue + + def deq_fn(current=layer): + return current.sdnq_dequantizer( + current.weight, current.scale, + zero_point=getattr(current, "zero_point", None), + svd_up=getattr(current, "svd_up", None), svd_down=getattr(current, "svd_down", None), + ) + + def fwd_fn(current=layer): + return current(x) + + try: + phase("compiling dequant") + with time_limit(config_timeout, row_label): + deq_out = deq_fn().to(torch.float32) + torch_device_module.synchronize() + entry["compiled_ms"] = bench(deq_fn, warmup, iters, on_phase=phase) + entry["weight_err"] = rel_err(deq_out, weight_fp32) + plain_err = (plain_results.get(dtype_id) or {}).get("weight_err") + entry["err_ratio"] = entry["weight_err"] / plain_err if plain_err else None + del deq_out + phase("timing linear forward") + with time_limit(config_timeout, row_label): + fwd_fn() + torch_device_module.synchronize() + entry["fwd_ms"] = bench(fwd_fn, warmup, iters) + table.add_row( + row_label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), + f"{entry['compiled_ms']:8.3f} ms", err_cell(entry["weight_err"]), + f"x{entry['err_ratio']:.2f}" if entry["err_ratio"] else "-", + f"{entry['fwd_ms']:8.3f} ms", + speedup_cell(base_ms, entry["fwd_ms"]) if base_ms else "-", + ) + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), "-", "-", "-", "-", failure_text(e)) + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + del layer + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + torch_device_module.empty_cache() + report["dequant_variants"] = dict(shape=shape_label, results=results) + return results + + +def bench_float_mm_alternatives(shape_label, out_features, in_features, plain_results, selected_dtypes, iters, warmup, config_timeout=300): + # explicit MatMul type for float storage dtypes: under auto these route quantized matmul to + # fp8, which not every gpu can run; measure what setting int8 or float16 costs instead + dtype_configs = [(dtype_id, label, cfg) for dtype_id, label, cfg in dequant_dtype_configs if dtype_id in float_mm_dtypes and (selected_dtypes is None or dtype_id in selected_dtypes)] + if not dtype_configs: + return {} + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("config") + table.add_column("quant", justify="right") + table.add_column("mm fwd", justify="right") + table.add_column("out err", justify="right") + table.add_column("vs dequant", justify="right") + panel = Panel(table, title=f"float weights, explicit MatMul type: {shape_label} {dtype_label()}", subtitle="[dim]quantized matmul with the MatMul type set explicitly; dequant path and auto rows repeated dimmed; vs dequant above x1.00 = faster than the dequant-path forward[/dim]", box=ROUNDED_BOX, expand=False) + + results = {} + runs = [(dtype_id, label, cfg, mm_dtype) for dtype_id, label, cfg in dtype_configs for mm_dtype in float_mm_alternative_dtypes] + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(dequant_forward_tokens, in_features, device=torch_device, dtype=bench_dtype, generator=generator) + ref_out = fp32_linear_reference(x, weight_fp32) + added_plain = set() + for index, (dtype_id, label, cfg, mm_dtype) in enumerate(runs, start=1): + row_label = f"{label} + {mm_dtype} mm" + def phase(step, current_label=row_label, current_index=index): + progress.update(task, description=f"float mm {current_index}/{len(runs)} {current_label}: {step}") + plain = plain_results.get(dtype_id) or {} + fwd_ms = plain.get("fwd_ms") + if dtype_id not in added_plain: + added_plain.add(dtype_id) + if fwd_ms: + table.add_row(f"[dim]{label} dequant path[/dim]", "-", f"[dim]{fwd_ms:8.3f} ms[/dim]", f"[dim]{plain['fwd_err']:.5f}[/dim]" if plain.get("fwd_err") else "-", "[dim]x1.00[/dim]") + if plain.get("mm_ms"): + table.add_row(f"[dim]{label} + auto ({plain.get('mm_dtype')})[/dim]", "-", f"[dim]{plain['mm_ms']:8.3f} ms[/dim]", f"[dim]{plain['mm_err']:.5f}[/dim]" if plain.get("mm_err") else "-", f"[dim]{speedup_cell(fwd_ms, plain['mm_ms'])}[/dim]" if fwd_ms else "-") + elif plain.get("mm_error"): + table.add_row(f"[dim]{label} + auto ({plain.get('mm_dtype') or 'float8_e4m3fn'})[/dim]", "-", failure_text(RuntimeError(plain["mm_error"])), "-", "-") + entry = dict(quant_s=None, mm_ms=None, mm_err=None, mm_dtype=None) + results[f"{dtype_id}+{mm_dtype}"] = entry + progress.reset(task) + phase("quantizing") + try: + layer, entry["quant_s"] = make_quantized_linear(weight, use_quantized_matmul=True, quantized_matmul_dtype=mm_dtype, **cfg) + entry["mm_dtype"] = layer.sdnq_dequantizer.quantized_matmul_dtype + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, "-", failure_text(e), "-", "-") + continue + + def mm_fn(current=layer): + return current(x) + + try: + phase("compiling quantized matmul forward") + with time_limit(config_timeout, row_label): + mm_fn() + torch_device_module.synchronize() + phase("timing quantized matmul forward") + entry["mm_ms"] = bench(mm_fn, warmup, iters) + entry["mm_err"] = rel_err(mm_fn(), ref_out) + table.add_row(row_label, quant_cell(entry["quant_s"]), f"{entry['mm_ms']:8.3f} ms", err_cell(entry["mm_err"]), speedup_cell(fwd_ms, entry["mm_ms"]) if fwd_ms else "-") + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, quant_cell(entry["quant_s"]), failure_text(e), "-", "-") + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + del layer + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + torch_device_module.empty_cache() + report["dequant_float_mm"] = dict(shape=shape_label, results=results) + return results + + +# === quantized matmul backends === +# +# The linear layers bind their scaled-mm function at import +# (`from ...kernel_wrappers import int_scaled_mm_func`), so SDNQ_USE_TRITON_MM freezes the +# backend for the process and a cross-process A/B carries clock drift into the comparison. +# The call sites look the name up as a module global at call time, so rebinding it on the +# consuming module switches backends in-process; the layer forwards are compile_func'd, so +# every swap needs a dynamo reset or the traced graph keeps calling the previous function. +# +# The torch row is whatever kernel_wrappers bound when triton was not selected, captured +# rather than reimplemented. Run without SDNQ_USE_TRITON_MM=1 to have it available: where +# triton is the platform default (xpu, ipex, zluda, rdna2 and older) the torch fallbacks are +# never defined and the row needs SDNQ_USE_TRITON_MM=0. + +mm_swap_targets = [ + ("modules.sdnq.layers.linear.linear_int8", "int_scaled_mm_func"), + ("modules.sdnq.layers.linear.linear_uint8", "int_scaled_mm_func"), + ("modules.sdnq.layers.linear.linear_fp16", "fp_scaled_mm_func"), + ("modules.sdnq.layers.linear.linear_fp8", "fp8_scaled_mm_func"), +] + + +def mm_backend_bindings(): + # {backend: {(module, attr): func}} for the backends bindable in this process, plus a + # note for any that are not + import importlib + bound = {} + for module_path, attr in mm_swap_targets: + try: + module = importlib.import_module(module_path) + except Exception: + continue + func = getattr(module, attr, None) + if func is not None: + bound[(module_path, attr)] = func + try: + from modules.sdnq.kernels.triton_scaled_mm import sdnq_scaled_mm + except Exception as e: + return {}, {"triton": f"triton scaled mm unavailable: {error_summary(e, 120)}"} + + backends, unavailable = {}, {} + if bound and all(func is sdnq_scaled_mm for func in bound.values()): + unavailable["torch"] = "triton is the default matmul backend on this device; rerun with SDNQ_USE_TRITON_MM=0 to bind the torch fallbacks" + elif bound: + backends["torch"] = dict(bound) + backends["triton"] = {target: sdnq_scaled_mm for target in bound} + return backends, unavailable + + +def apply_mm_backend(binding): + import importlib + for (module_path, attr), func in binding.items(): + setattr(importlib.import_module(module_path), attr, func) + torch._dynamo.reset() # pylint: disable=protected-access # layer forwards are compiled: the traced graph pins the previous function + + +def bench_mm_backends(shape_label, out_features, in_features, selected_dtypes, backends, iters, warmup, config_timeout=300, rounds=2): + # paired same-run comparison of the quantized-matmul backends: one quantized layer per + # dtype, benched through each backend in turn so both rows see the same weights and the + # same clock state. Round order alternates so monotonic drift cancels instead of + # accumulating into whichever backend runs second; each row keeps its fastest round. + available, unavailable = mm_backend_bindings() + selected = [name for name in backends if name in available] + for name in backends: + if name in unavailable: + emit(f"[yellow]matmul backend '{name}' not benchable: {unavailable[name]}[/yellow]") + if len(selected) < 2: + if selected: + emit(f"[yellow]matmul backend comparison needs two bindable backends, only '{selected[0]}' is available; skipping[/yellow]") + return {} + dtype_configs = [(dtype_id, label, cfg) for dtype_id, label, cfg in dequant_dtype_configs if selected_dtypes is None or dtype_id in selected_dtypes] + if not dtype_configs: + return {} + # the comparison only runs when the torch row is bindable, which means the process came up on + # it; restore it after the sweep so later sections measure the config the user actually runs + original_binding = available["torch"] + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("weights") + for name in selected: + table.add_column(f"{name} mm", justify="right") + table.add_column("delta", justify="right") + table.add_column("out err", justify="right") + panel = Panel( + table, + title=f"quantized matmul backends, paired: {shape_label} {dtype_label()}", + subtitle=f"[dim]same layer and clock state, {rounds} alternating rounds, fastest kept; delta = {selected[-1]} vs {selected[0]}, negative = {selected[-1]} faster[/dim]", + box=ROUNDED_BOX, expand=False, + ) + + results = {} + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(dequant_forward_tokens, in_features, device=torch_device, dtype=bench_dtype, generator=generator) + ref_out = fp32_linear_reference(x, weight_fp32) + for index, (dtype_id, label, cfg) in enumerate(dtype_configs, start=1): + def phase(step, current_label=label, current_index=index): + progress.update(task, description=f"mm backends {current_index}/{len(dtype_configs)} {current_label}: {step}") + entry = dict(mm_dtype=None, backends={}) + results[dtype_id] = entry + try: + phase("quantizing for quantized matmul") + layer, _quant_seconds = make_quantized_linear(weight, use_quantized_matmul=True, **cfg) + entry["mm_dtype"] = layer.sdnq_dequantizer.quantized_matmul_dtype + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(label, *["-"] * len(selected), "-", failure_text(e)) + continue + + def mm_fn(current=layer): + return current(x) + + for round_index in range(rounds): + order = selected if round_index % 2 == 0 else list(reversed(selected)) + for name in order: + slot = entry["backends"].setdefault(name, dict(ms=None, err=None)) + if slot.get("error"): + continue + try: + phase(f"{name} backend, round {round_index + 1}/{rounds}") + apply_mm_backend(available[name]) + with time_limit(config_timeout, f"{label} {name} mm"): + mm_fn() + torch_device_module.synchronize() + ms = bench(mm_fn, warmup, iters) + if slot["ms"] is None or ms < slot["ms"]: + slot["ms"] = ms + if slot["err"] is None: + slot["err"] = rel_err(mm_fn(), ref_out) + except Exception as e: + slot["error"] = error_summary(e, 200) + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + del layer + + cells = [] + for name in selected: + slot = entry["backends"].get(name, {}) + cells.append(f"{slot['ms']:8.3f} ms" if slot.get("ms") else failure_text(RuntimeError(slot.get("error", "not run")))) + first, last = entry["backends"].get(selected[0], {}), entry["backends"].get(selected[-1], {}) + if first.get("ms") and last.get("ms"): + delta = (last["ms"] - first["ms"]) / first["ms"] * 100 + colour = "green" if delta < -3 else ("red" if delta > 3 else "dim") + entry["delta_pct"] = delta + delta_cell = f"[{colour}]{delta:+.1f}%[/{colour}]" + else: + delta_cell = "-" + errs = {slot.get("err") for slot in entry["backends"].values() if slot.get("err") is not None} + err_text = err_cell(max(errs)) if errs else "-" + if len(errs) > 1 and max(errs) - min(errs) > 1e-4: + err_text += " [yellow]differs[/yellow]" # backends must be numerically equivalent; a split here is a kernel bug + table.add_row(label, *cells, delta_cell, err_text) + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + + apply_mm_backend(original_binding) + torch_device_module.empty_cache() + report["dequant_mm_backends"] = dict(shape=shape_label, backends=selected, rounds=rounds, results=results) + return results + + +def resolved_group_label(layer, in_features): + # infer the group size sdnq actually used from the stored scale shape: grouped scales are + # [out, groups, 1], row-wise scales collapse the group axis + scale = getattr(layer, "scale", None) + if scale is None: + return "-" + if scale.ndim >= 3 and scale.shape[1] > 1: + return f"g{in_features // scale.shape[1]}" + return "row" + + +def bench_group_sizes(shape_label, out_features, in_features, plain_results, selected_dtypes, iters, warmup, config_timeout=300): + # the Group size setting: 0 = auto, -1 = row-wise, explicit values snap to a divisor of + # in_features; grouping forces a per-forward re-quantize when quantized matmul is on, so + # the mm cells price that cost alongside the accuracy gain + dtype_configs = [(dtype_id, label, cfg) for dtype_id, label, cfg in dequant_dtype_configs if dtype_id in group_sweep_dtypes and (selected_dtypes is None or dtype_id in selected_dtypes)] + if not dtype_configs: + return {} + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("config") + table.add_column("quant", justify="right") + table.add_column("size", justify="right") + table.add_column("weight err", justify="right") + table.add_column("fwd", justify="right") + table.add_column("quantized mm", justify="right") + table.add_column("mm err", justify="right") + panel = Panel(table, title=f"group size sweep: {shape_label} {dtype_label()}", subtitle="[dim]Group size setting; auto and the mm path can resolve to different groups, resolved size shown per cell[/dim]", box=ROUNDED_BOX, expand=False) + + results = {} + runs = [(dtype_id, label, cfg, group) for dtype_id, label, cfg in dtype_configs for group in group_sweep_values] + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(dequant_forward_tokens, in_features, device=torch_device, dtype=bench_dtype, generator=generator) + ref_out = fp32_linear_reference(x, weight_fp32) + for index, (dtype_id, label, cfg, group) in enumerate(runs, start=1): + group_label = {0: "auto", -1: "row"}.get(group, str(group)) + row_label = f"{label} group {group_label}" + def phase(step, current_label=row_label, current_index=index): + progress.update(task, description=f"group {current_index}/{len(runs)} {current_label}: {step}") + entry = dict(quant_s=None, size_bytes=None, weight_err=None, fwd_ms=None, mm_ms=None, mm_err=None, group=group, resolved=None, mm_resolved=None) + results[f"{dtype_id}@{group}"] = entry + progress.reset(task) + phase("quantizing") + base_cfg = {key: value for key, value in cfg.items() if key != "group_size"} + try: + layer, entry["quant_s"] = make_quantized_linear(weight, group_size=group, **base_cfg) + entry["size_bytes"] = layer_storage_bytes(layer) + entry["resolved"] = resolved_group_label(layer, in_features) + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, "-", "-", failure_text(e), "-", "-", "-") + continue + + def fwd_fn(current=layer): + return current(x) + + try: + phase("timing dequant and forward") + with time_limit(config_timeout, row_label): + deq_out = layer.sdnq_dequantizer( + layer.weight, layer.scale, + zero_point=getattr(layer, "zero_point", None), + svd_up=getattr(layer, "svd_up", None), svd_down=getattr(layer, "svd_down", None), + ).to(torch.float32) + fwd_fn() + torch_device_module.synchronize() + entry["weight_err"] = rel_err(deq_out, weight_fp32) + del deq_out + entry["fwd_ms"] = bench(fwd_fn, warmup, iters) + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), "-", failure_text(e), "-", "-") + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + del layer + continue + del layer + + mm_cell, mm_err_cell = "-", "-" + try: + phase("quantizing for quantized matmul") + mm_layer, _mm_quant_seconds = make_quantized_linear(weight, group_size=group, use_quantized_matmul=True, **base_cfg) + entry["mm_resolved"] = resolved_group_label(mm_layer, in_features) + def mm_fn(current=mm_layer): + return current(x) + phase("timing quantized matmul forward") + with time_limit(config_timeout, row_label): + mm_fn() + torch_device_module.synchronize() + entry["mm_ms"] = bench(mm_fn, warmup, iters) + entry["mm_err"] = rel_err(mm_fn(), ref_out) + mm_suffix = f" [dim]{entry['mm_resolved']}[/dim]" if entry["mm_resolved"] != entry["resolved"] else "" + mm_cell = f"{entry['mm_ms']:8.3f} ms{mm_suffix}" + mm_err_cell = err_cell(entry["mm_err"]) + del mm_layer + except Exception as e: + entry["mm_error"] = error_summary(e, 200) + mm_cell = failure_text(e) + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + + shown_label = f"{row_label} [dim]({entry['resolved']})[/dim]" if group == 0 else row_label + table.add_row(shown_label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), err_cell(entry["weight_err"]), f"{entry['fwd_ms']:8.3f} ms", mm_cell, mm_err_cell) + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + torch_device_module.empty_cache() + report["dequant_group_sizes"] = dict(shape=shape_label, results=results) + return results + + +def bench_svd_ranks(shape_label, out_features, in_features, plain_results, selected_dtypes, iters, warmup, config_timeout=300): + # the SVD rank size setting: rank drives both outlier absorption and the rank x (in + out) + # fp16 size overhead; plain no-svd rows repeated dimmed for comparison + dtype_configs = [(dtype_id, label, cfg) for dtype_id, label, cfg in dequant_dtype_configs if dtype_id in svd_rank_sweep_dtypes and (selected_dtypes is None or dtype_id in selected_dtypes)] + if not dtype_configs: + return {} + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("config") + table.add_column("quant", justify="right") + table.add_column("size", justify="right") + table.add_column("weight err", justify="right") + table.add_column("err vs plain", justify="right") + table.add_column("fwd", justify="right") + panel = Panel(table, title=f"svd rank sweep: {shape_label} {dtype_label()}", subtitle="[dim]SVD rank size setting at svd steps 8; err vs plain below x1.00 = better reconstruction[/dim]", box=ROUNDED_BOX, expand=False) + + results = {} + runs = [(dtype_id, label, cfg, rank) for dtype_id, label, cfg in dtype_configs for rank in svd_rank_sweep_values] + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(dequant_forward_tokens, in_features, device=torch_device, dtype=bench_dtype, generator=generator) + added_plain = set() + for index, (dtype_id, label, cfg, rank) in enumerate(runs, start=1): + row_label = f"{label} + svd rank {rank}" + def phase(step, current_label=row_label, current_index=index): + progress.update(task, description=f"svd {current_index}/{len(runs)} {current_label}: {step}") + plain = plain_results.get(dtype_id) or {} + if dtype_id not in added_plain: + added_plain.add(dtype_id) + if plain.get("weight_err") is not None: + plain_fwd = plain.get("fwd_ms") + table.add_row(f"[dim]{label}[/dim]", f"[dim]{quant_cell(plain.get('quant_s'))}[/dim]", f"[dim]{size_cell(plain['size_bytes'])}[/dim]", f"[dim]{plain['weight_err']:.5f}[/dim]", "[dim]x1.00[/dim]", f"[dim]{plain_fwd:8.3f} ms[/dim]" if plain_fwd else "-") + entry = dict(quant_s=None, size_bytes=None, weight_err=None, err_ratio=None, fwd_ms=None, rank=rank) + results[f"{dtype_id}@{rank}"] = entry + progress.reset(task) + phase("quantizing (svd)") + try: + layer, entry["quant_s"] = make_quantized_linear(weight, use_svd=True, svd_rank=rank, **cfg) + entry["size_bytes"] = layer_storage_bytes(layer) + def fwd_fn(current=layer): + return current(x) + phase("timing dequant and forward") + with time_limit(config_timeout, row_label): + deq_out = layer.sdnq_dequantizer( + layer.weight, layer.scale, + zero_point=getattr(layer, "zero_point", None), + svd_up=getattr(layer, "svd_up", None), svd_down=getattr(layer, "svd_down", None), + ).to(torch.float32) + fwd_fn() + torch_device_module.synchronize() + entry["weight_err"] = rel_err(deq_out, weight_fp32) + del deq_out + plain_err = plain.get("weight_err") + entry["err_ratio"] = entry["weight_err"] / plain_err if plain_err else None + entry["fwd_ms"] = bench(fwd_fn, warmup, iters) + table.add_row(row_label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), err_cell(entry["weight_err"]), f"x{entry['err_ratio']:.2f}" if entry["err_ratio"] else "-", f"{entry['fwd_ms']:8.3f} ms") + del layer + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, quant_cell(entry["quant_s"]), "-", "-", "-", failure_text(e)) + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + torch_device_module.empty_cache() + report["dequant_svd_ranks"] = dict(shape=shape_label, results=results) + return results + + +def bench_hadamard_groups(shape_label, out_features, in_features, plain_results, selected_dtypes, iters, warmup, config_timeout=300): + # the weight-side Hadamard group size setting, swept on int8 where rotation measured the + # largest gain; unlike the attention slider it is not clamped to head dim + if selected_dtypes is not None and "int8" not in selected_dtypes: + return {} + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("config") + table.add_column("quant", justify="right") + table.add_column("size", justify="right") + table.add_column("weight err", justify="right") + table.add_column("err vs plain", justify="right") + table.add_column("fwd", justify="right") + panel = Panel(table, title=f"hadamard group size sweep: int8 {shape_label} {dtype_label()}", subtitle="[dim]weight-side Hadamard group size setting; err vs plain below x1.00 = better reconstruction[/dim]", box=ROUNDED_BOX, expand=False) + + results = {} + plain = plain_results.get("int8") or {} + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(dequant_forward_tokens, in_features, device=torch_device, dtype=bench_dtype, generator=generator) + if plain.get("weight_err") is not None: + plain_fwd = plain.get("fwd_ms") + table.add_row("[dim]int8[/dim]", f"[dim]{quant_cell(plain.get('quant_s'))}[/dim]", f"[dim]{size_cell(plain['size_bytes'])}[/dim]", f"[dim]{plain['weight_err']:.5f}[/dim]", "[dim]x1.00[/dim]", f"[dim]{plain_fwd:8.3f} ms[/dim]" if plain_fwd else "-") + for index, hgroup in enumerate(hadamard_group_values, start=1): + row_label = f"int8 + hadamard group {hgroup}" + def phase(step, current_label=row_label, current_index=index): + progress.update(task, description=f"hadamard group {current_index}/{len(hadamard_group_values)} {current_label}: {step}") + entry = dict(quant_s=None, size_bytes=None, weight_err=None, err_ratio=None, fwd_ms=None, hgroup=hgroup) + results[str(hgroup)] = entry + progress.reset(task) + phase("quantizing (hadamard)") + try: + layer, entry["quant_s"] = make_quantized_linear(weight, "int8", use_hadamard=True, hadamard_group_size=hgroup) + entry["size_bytes"] = layer_storage_bytes(layer) + def fwd_fn(current=layer): + return current(x) + phase("timing dequant and forward") + with time_limit(config_timeout, row_label): + deq_out = layer.sdnq_dequantizer( + layer.weight, layer.scale, + zero_point=getattr(layer, "zero_point", None), + svd_up=getattr(layer, "svd_up", None), svd_down=getattr(layer, "svd_down", None), + ).to(torch.float32) + fwd_fn() + torch_device_module.synchronize() + entry["weight_err"] = rel_err(deq_out, weight_fp32) + del deq_out + plain_err = plain.get("weight_err") + entry["err_ratio"] = entry["weight_err"] / plain_err if plain_err else None + entry["fwd_ms"] = bench(fwd_fn, warmup, iters) + table.add_row(row_label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), err_cell(entry["weight_err"]), f"x{entry['err_ratio']:.2f}" if entry["err_ratio"] else "-", f"{entry['fwd_ms']:8.3f} ms") + del layer + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, quant_cell(entry["quant_s"]), "-", "-", "-", failure_text(e)) + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + torch_device_module.empty_cache() + report["dequant_hadamard_groups"] = dict(shape=shape_label, results=results) + return results + + +def bench_quant_toggles(shape_label, out_features, in_features, plain_results, selected_dtypes, iters, warmup, config_timeout=300): + # remaining checkbox-level settings: Dequantize using full precision off (scales kept in + # the model dtype instead of fp32), Dynamic quantization (per-layer dtype escalation until + # the loss threshold passes), and Quantize using GPU (quantization wall time on cpu) + fp32_dtypes = [(dtype_id, label, cfg) for dtype_id, label, cfg in dequant_dtype_configs if dtype_id in toggle_dtypes and (selected_dtypes is None or dtype_id in selected_dtypes)] + results = dict(fp32_off={}, dynamic={}, cpu_quant_s=None, gpu_quant_s=None) + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("config") + table.add_column("quant", justify="right") + table.add_column("size", justify="right") + table.add_column("weight err", justify="right") + table.add_column("fwd", justify="right") + panel = Panel(table, title=f"dequantize full precision off: {shape_label} {dtype_label()}", subtitle="[dim]Dequantize using full precision unchecked; full-precision rows repeated dimmed[/dim]", box=ROUNDED_BOX, expand=False) + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(dequant_forward_tokens, in_features, device=torch_device, dtype=bench_dtype, generator=generator) + for index, (dtype_id, label, cfg) in enumerate(fp32_dtypes, start=1): + row_label = f"{label} + fp32 dequant off" + def phase(step, current_label=row_label, current_index=index): + progress.update(task, description=f"toggle {current_index}/{len(fp32_dtypes)} {current_label}: {step}") + plain = plain_results.get(dtype_id) or {} + if plain.get("weight_err") is not None: + plain_fwd = plain.get("fwd_ms") + table.add_row(f"[dim]{label}[/dim]", f"[dim]{quant_cell(plain.get('quant_s'))}[/dim]", f"[dim]{size_cell(plain['size_bytes'])}[/dim]", f"[dim]{plain['weight_err']:.5f}[/dim]", f"[dim]{plain_fwd:8.3f} ms[/dim]" if plain_fwd else "-") + entry = dict(quant_s=None, size_bytes=None, weight_err=None, fwd_ms=None) + results["fp32_off"][dtype_id] = entry + progress.reset(task) + phase("quantizing") + try: + layer, entry["quant_s"] = make_quantized_linear(weight, dequantize_fp32=False, **cfg) + entry["size_bytes"] = layer_storage_bytes(layer) + def fwd_fn(current=layer): + return current(x) + phase("timing dequant and forward") + with time_limit(config_timeout, row_label): + deq_out = layer.sdnq_dequantizer( + layer.weight, layer.scale, + zero_point=getattr(layer, "zero_point", None), + svd_up=getattr(layer, "svd_up", None), svd_down=getattr(layer, "svd_down", None), + ).to(torch.float32) + fwd_fn() + torch_device_module.synchronize() + entry["weight_err"] = rel_err(deq_out, weight_fp32) + del deq_out + entry["fwd_ms"] = bench(fwd_fn, warmup, iters) + table.add_row(row_label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), err_cell(entry["weight_err"]), f"{entry['fwd_ms']:8.3f} ms") + del layer + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(row_label, quant_cell(entry["quant_s"]), "-", "-", failure_text(e)) + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + + dyn_table = Table(box=box.SIMPLE_HEAVY) + dyn_table.add_column("requested") + dyn_table.add_column("chosen", justify="center") + dyn_table.add_column("quant", justify="right") + dyn_table.add_column("size", justify="right") + dyn_table.add_column("weight err", justify="right") + dyn_panel = Panel(dyn_table, title=f"dynamic quantization: {shape_label} {dtype_label()}", subtitle="[dim]Use Dynamic quantization: escalates to wider dtypes until normalized mse passes the loss threshold (default 10^-(bits/2))[/dim]", box=ROUNDED_BOX, expand=False) + progress, task = live_progress() + with Live(Group(dyn_panel, progress), console=console, refresh_per_second=4) as live: + weight = make_source_weight(out_features, in_features) + weight_fp32 = weight.to(torch.float32) + for index, requested in enumerate(dynamic_quant_requests, start=1): + progress.reset(task) + progress.update(task, description=f"dynamic {index}/{len(dynamic_quant_requests)} requested {requested}") + entry = dict(quant_s=None, chosen=None, size_bytes=None, weight_err=None) + results["dynamic"][requested] = entry + try: + layer, entry["quant_s"] = make_quantized_linear(weight, requested, use_dynamic_quantization=True) + entry["chosen"] = layer.sdnq_dequantizer.weights_dtype + entry["size_bytes"] = layer_storage_bytes(layer) + deq_out = layer.sdnq_dequantizer( + layer.weight, layer.scale, + zero_point=getattr(layer, "zero_point", None), + svd_up=getattr(layer, "svd_up", None), svd_down=getattr(layer, "svd_down", None), + skip_compile=True, + ).to(torch.float32) + entry["weight_err"] = rel_err(deq_out, weight_fp32) + del deq_out, layer + chosen_cell = entry["chosen"] if entry["chosen"] == requested else f"[yellow]{entry['chosen']}[/yellow]" + dyn_table.add_row(requested, chosen_cell, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), err_cell(entry["weight_err"])) + except Exception as e: + entry["error"] = error_summary(e, 200) + dyn_table.add_row(requested, "[red]unquantized[/red]", "-", "-", failure_text(e)) + live.update(dyn_panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(dyn_panel) + + # Quantize using GPU: one int8 layer quantized on cpu for the wall-time comparison + try: + weight_cpu = make_source_weight(out_features, in_features).cpu() + _cpu_layer, results["cpu_quant_s"] = make_quantized_linear(weight_cpu, "int8", device="cpu") + del _cpu_layer, weight_cpu + results["gpu_quant_s"] = (plain_results.get("int8") or {}).get("quant_s") + except Exception as e: + results["cpu_quant_error"] = error_summary(e, 200) + torch_device_module.empty_cache() + report["dequant_toggles"] = dict(shape=shape_label, results=results) + return results + + +def make_source_conv_weight(out_channels, in_channels, kernel, seed=1234): + # conv analogue of make_source_weight: a few high-magnitude input channels + generator = torch.Generator(device=torch_device).manual_seed(seed) + weight = torch.randn(out_channels, in_channels, kernel, kernel, device=torch_device, dtype=bench_dtype, generator=generator) * 0.02 + weight[:, [1, in_channels // 2, in_channels - 2]] *= 8.0 + return weight + + +def fp32_conv_reference(x, weight_fp32, padding): + # convs route through cudnn, which has its own tf32 switch on top of the matmul one + tf32_matmul = torch.backends.cuda.matmul.allow_tf32 + tf32_cudnn = torch.backends.cudnn.allow_tf32 + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + try: + return torch.nn.functional.conv2d(x.to(torch.float32), weight_fp32, padding=padding) + finally: + torch.backends.cuda.matmul.allow_tf32 = tf32_matmul + torch.backends.cudnn.allow_tf32 = tf32_cudnn + + +def make_quantized_conv(weight, weights_dtype, use_quantized_matmul=False): + from modules.sdnq import SDNQConfig + from modules.sdnq.quantizer import sdnq_quantize_layer + out_channels, in_channels, kh, kw = weight.shape + conv = torch.nn.Conv2d(in_channels, out_channels, (kh, kw), padding=(kh // 2, kw // 2), bias=False, device=torch_device, dtype=bench_dtype) + with torch.no_grad(): + conv.weight.copy_(weight) + config = SDNQConfig(weights_dtype=weights_dtype, quant_conv=True, use_quantized_matmul_conv=use_quantized_matmul, add_skip_keys=False) + torch_device_module.synchronize() + started = time.perf_counter() + layer, _config = sdnq_quantize_layer(conv, config, torch_dtype=bench_dtype, param_name="bench.weight") + torch_device_module.synchronize() + quant_seconds = time.perf_counter() - started + if not hasattr(layer, "sdnq_dequantizer"): + raise RuntimeError(f"sdnq did not quantize the conv layer to {weights_dtype}") + return layer, quant_seconds + + +def bench_conv_section(iters, warmup, config_timeout=300): + # the Quantize convolutional layers and Use quantized MatMul with conv settings, measured + # on real Conv2d layers; dit models have no convs, this is for unet and vae model classes + all_results = {} + for shape_label, out_channels, in_channels, kernel, px in conv_shapes: + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("config") + table.add_column("quant", justify="right") + table.add_column("size", justify="right") + table.add_column("weight err", justify="right") + table.add_column("fwd", justify="right") + table.add_column("out err", justify="right") + table.add_column("speedup", justify="right") + panel = Panel(table, title=f"conv quantization: {shape_label} {dtype_label()}", subtitle="[dim]bias-free conv2d, batch 1, errors vs true fp32 (tf32 off); mm rows use the conv quantized matmul path[/dim]", box=ROUNDED_BOX, expand=False) + results = {} + base_ms = None + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + progress.update(task, description=f"{shape_label}: preparing weights and fp32 reference") + weight = make_source_conv_weight(out_channels, in_channels, kernel) + weight_fp32 = weight.to(torch.float32) + generator = torch.Generator(device=torch_device).manual_seed(42) + x = torch.randn(1, in_channels, px, px, device=torch_device, dtype=bench_dtype, generator=generator) + ref_out = fp32_conv_reference(x, weight_fp32, kernel // 2) + for index, (config_id, weights_cfg, use_mm) in enumerate(conv_configs, start=1): + label = f"{dtype_label()} conv2d" if weights_cfg is None else f"{weights_cfg['weights_dtype']}{' + conv mm' if use_mm else ''}" + def phase(step, current_label=label, current_index=index, current_progress=progress, current_task=task, current_shape=shape_label): + current_progress.update(current_task, description=f"conv {current_index}/{len(conv_configs)} {current_shape} {current_label}: {step}") + entry = dict(quant_s=None, size_bytes=None, weight_err=None, fwd_ms=None, out_err=None) + results[config_id] = entry + progress.reset(task) + try: + if weights_cfg is None: + layer = torch.nn.Conv2d(in_channels, out_channels, (kernel, kernel), padding=(kernel // 2, kernel // 2), bias=False, device=torch_device, dtype=bench_dtype) + with torch.no_grad(): + layer.weight.copy_(weight) + entry["size_bytes"] = layer.weight.numel() * layer.weight.element_size() + weight_err_cell = "-" + else: + phase("quantizing") + layer, entry["quant_s"] = make_quantized_conv(weight, use_quantized_matmul=use_mm, **weights_cfg) + entry["size_bytes"] = layer_storage_bytes(layer) + deq_out = layer.sdnq_dequantizer( + layer.weight, layer.scale, + zero_point=getattr(layer, "zero_point", None), + svd_up=getattr(layer, "svd_up", None), svd_down=getattr(layer, "svd_down", None), + skip_quantized_matmul=use_mm, skip_compile=True, + ).to(torch.float32) + entry["weight_err"] = rel_err(deq_out, weight_fp32) + weight_err_cell = err_cell(entry["weight_err"]) + del deq_out + def fwd_fn(current=layer, current_x=x): + return current(current_x) + phase("timing conv forward") + with time_limit(config_timeout, label): + fwd_fn() + torch_device_module.synchronize() + entry["fwd_ms"] = bench(fwd_fn, warmup, iters) + entry["out_err"] = rel_err(fwd_fn(), ref_out) + if base_ms is None: + base_ms = entry["fwd_ms"] + table.add_row(label, quant_cell(entry["quant_s"]), size_cell(entry["size_bytes"]), weight_err_cell, f"{entry['fwd_ms']:8.3f} ms", err_cell(entry["out_err"]), speedup_cell(base_ms, entry["fwd_ms"])) + del layer + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(label, quant_cell(entry["quant_s"]), "-", "-", failure_text(e), "-", "-") + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + torch_device_module.empty_cache() + all_results[shape_label] = results + report["dequant_conv"] = all_results + return all_results + + +def block_label(weights_cfg, use_mm, attention_spec): + if weights_cfg is None: + weights_part = dtype_label() + else: + weights_part = weights_cfg["weights_dtype"] + (" g16" if weights_cfg.get("group_size") == 16 else "") + if use_mm: + weights_part += " mm" + return f"{weights_part} + {attention_spec}" + + +def bench_block_section(iters, warmup, config_timeout=300, selected=None): + # each row is a complete configuration measured end to end through a dit block, because + # component speedups and errors do not compose multiplicatively + configs = [c for c in block_configs if selected is None or c[0] in selected] + sage_missing = {"sage": sage_attention() is None, "sage fp16 accum": sage_attention_fp16_accum() is None} + skipped = [config_id for config_id, _w, _mm, spec in configs if sage_missing.get(spec, False)] + if skipped: + configs = [c for c in configs if c[0] not in skipped] + emit(f"[dim]block: skipping {', '.join(skipped)}, sageattention (or this accumulation mode) is unavailable here[/dim]") + if not configs: + return {} + hidden, heads, mlp_dim, tokens = block_geometry["hidden"], block_geometry["heads"], block_geometry["mlp_dim"], block_geometry["tokens"] + + table = Table(box=box.SIMPLE_HEAVY) + table.add_column("config") + table.add_column("size", justify="right") + table.add_column("block ms", justify="right") + table.add_column("speedup", justify="right") + table.add_column("out err", justify="right") + table.add_column("max tok err", justify="right") + table.add_column("err x4 blocks", justify="right") + panel = Panel(table, title=f"combined block: hidden={hidden} heads={heads} mlp={mlp_dim} tokens={tokens} {dtype_label()}", subtitle="[dim]dit block, fused qkv + gelu mlp with residuals; err vs an fp32 reference block, max tok = worst single token, x4 = four stacked blocks[/dim]", box=ROUNDED_BOX, expand=False) + + def run_depth(block, x0, depth): + h = x0 + for _ in range(depth): + h = block(h) + return h + + results = {} + base_ms = None + progress, task = live_progress() + with Live(Group(panel, progress), console=console, refresh_per_second=4) as live: + progress.update(task, description="block: building master weights and the fp32 reference") + master = make_block_master() + generator = torch.Generator(device=torch_device).manual_seed(7) + x = torch.randn(1, tokens, hidden, device=torch_device, dtype=bench_dtype, generator=generator) + ref_block = BenchBlock(hidden, heads, mlp_dim, device=torch_device, dtype=torch.float32) + ref_block.load_state_dict(master) + ref_block.eval() + def ref_attention(q, k, v): + return torch.nn.functional.scaled_dot_product_attention(q, k, v) + ref_block.attention_fn = ref_attention + tf32_matmul = torch.backends.cuda.matmul.allow_tf32 + tf32_cudnn = torch.backends.cudnn.allow_tf32 + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + try: + with torch.no_grad(): + x_fp32 = x.to(torch.float32) + ref_out = ref_block(x_fp32) + ref_out4 = run_depth(ref_block, x_fp32, 4) + finally: + torch.backends.cuda.matmul.allow_tf32 = tf32_matmul + torch.backends.cudnn.allow_tf32 = tf32_cudnn + del ref_block, x_fp32 + torch_device_module.empty_cache() + + for index, (config_id, weights_cfg, use_mm, attention_spec) in enumerate(configs, start=1): + label = block_label(weights_cfg, use_mm, attention_spec) + def phase(step, current_label=label, current_index=index): + progress.update(task, description=f"block config {current_index}/{len(configs)} {current_label}: {step}") + entry = dict(ms=None, err=None, max_err=None, err4=None, size_bytes=None, label=label) + results[config_id] = entry + progress.reset(task) + phase("quantizing block") + try: + block = build_bench_block(master, weights_cfg, use_mm, attention_spec) + entry["size_bytes"] = block_storage_bytes(block) + + def fn(current=block): + with torch.no_grad(): + return current(x) + + phase("compiling") + with time_limit(config_timeout, label): + out = fn() + torch_device_module.synchronize() + entry["ms"] = bench(fn, warmup, iters, on_phase=phase) + entry["err"] = rel_err(out, ref_out) + entry["max_err"] = max_token_err(out, ref_out) + phase("measuring depth-4 error") + with torch.no_grad(): + entry["err4"] = rel_err(run_depth(block, x, 4), ref_out4) + del block, out + if base_ms is None: + base_ms = entry["ms"] + table.add_row(label, size_cell(entry["size_bytes"]), f"{entry['ms']:8.3f} ms", speedup_cell(base_ms, entry["ms"]), err_cell(entry["err"]), err_cell(entry["max_err"]), err_cell(entry["err4"])) + except Exception as e: + entry["error"] = error_summary(e, 200) + table.add_row(label, size_cell(entry["size_bytes"]) if entry["size_bytes"] else "-", "-", "-", "-", "-", failure_text(e)) + torch._dynamo.reset() # pylint: disable=protected-access # drop failed compile state + live.update(panel) + console.line() # separate sections; Live's final frame also lacks a trailing newline when output is piped + transcript.append(panel) + torch_device_module.empty_cache() + + notes = [] + sized = [(entry["label"], entry["ms"], entry["err"]) for entry in results.values() if entry.get("ms") and entry.get("err") is not None and math.isfinite(entry["err"])] + frontier = sorted((c for c in sized if not any(o is not c and o[1] <= c[1] and o[2] <= c[2] for o in sized)), key=lambda c: c[1]) + if len(frontier) > 1: + notes.append("speed/error frontier: " + ", ".join(f"{label} {ms:.2f}ms err {err:.4f}" for label, ms, err in frontier)) + growth = [entry["err4"] / entry["err"] for entry in results.values() if entry.get("err") and entry.get("err4") and math.isfinite(entry["err4"] / entry["err"])] + if growth: + notes.append(f"output error grows x{sum(growth) / len(growth):.2f} on average over four stacked blocks; residual connections dampen compounding") + weights_mode = str(getattr(shared.opts, "sdnq_quantize_weights_mode", "")) + current_id = None + if weights_mode == "int8" and getattr(shared.opts, "sdnq_use_quantized_matmul", False): + current_id = "int8-mm-atten" if "SDNQ attention" in shared.opts.sdp_overrides else "int8-mm" + if current_id and results.get(current_id, {}).get("ms"): + notes.append(f"the {results[current_id]['label']} row is what the current config runs for int8-quantized models") + if any(entry.get("ms") for config_id, entry in results.items() if config_id.endswith("sagefp16")): + notes.append("sage fp16 accum is a benchmark-only baseline: no sdnext setting reaches it (sage is pinned to fp32 accumulation on sm86 and sage's own dispatch never selects fp16 accum elsewhere)") + if notes: + emit(Panel("\n".join(notes), title="block notes", box=ROUNDED_BOX)) + report["block"] = dict(geometry=dict(block_geometry), results=results) + return results + + +def measured(results, config_id): + entry = results.get(config_id) or {} + ms = entry.get("ms") + return (ms, entry.get("err")) if ms is not None else (None, None) + + +def best_config(results): + # lowest error among rows within 5% of the fastest sdnq time + candidates = [(config_id, entry["ms"], entry["err"]) for config_id, entry in results.items() if entry.get("ms") is not None and config_id not in external_config_ids] + if not candidates: + return None + fastest = min(ms for _config_id, ms, _err in candidates) + near_fastest = [(config_id, ms, err) for config_id, ms, err in candidates if ms <= fastest * 1.05] + return min(near_fastest, key=lambda item: item[2])[0] + + +def build_recommendations(all_results, fp8_result, prep_status): + # prefer an image dit shape with the full config set as reference, then the video shapes + reference = None + for preset in recommendation_presets: + if preset in all_results and measured(all_results[preset], "int8")[0] is not None: + reference = preset + break + if reference is None: + emit(f"[yellow]attention recommendations need a successful int8 run at a self-attention reference shape ({', '.join(recommendation_presets)}); none was benchmarked[/yellow]") + return + results = all_results[reference] + base_ms, _base_err = measured(results, "base") + noquant_ms, noquant_err = measured(results, "noquant") + int8_ms, int8_err = measured(results, "int8") + + table = Table(title=f"recommended settings (Compute Settings -> SDNQ Attention), measured at the {reference} shape", box=ROUNDED_BOX) + table.add_column("setting") + table.add_column("current", justify="center") + table.add_column("recommended", justify="center") + table.add_column("reason") + + def current(key): + return str(getattr(shared.opts, key)) + + rows = [] + # compare against the unquantized sdnq row: quantization has to pay for its own prep + use_quantized = bool(int8_ms and noquant_ms and int8_ms < noquant_ms * 0.95) + if int8_ms and noquant_ms: + if use_quantized: + quant_reason = f"int8 qk measured x{noquant_ms / int8_ms:.2f} vs unquantized sdnq attention" + if int8_err and noquant_err: + quant_reason += f", error {int8_err:.5f} vs {noquant_err:.5f}; smooth k and hadamard below buy error back" + else: + quant_reason = f"unquantized sdnq measured x{int8_ms / noquant_ms:.2f} vs int8 qk with lower error; quantization prep outweighs the kernel gain on this gpu" + rows.append(("Use Quantized MatMul", current("sdnq_attention_use_quantized_matmul"), str(use_quantized), quant_reason)) + elif int8_ms and base_ms: + use_quantized = base_ms / int8_ms >= 1.10 + rows.append(("Use Quantized MatMul", current("sdnq_attention_use_quantized_matmul"), str(use_quantized), f"int8 qk measured x{base_ms / int8_ms:.2f} vs torch sdpa; unquantized sdnq row unavailable")) + else: + rows.append(("Use Quantized MatMul", current("sdnq_attention_use_quantized_matmul"), "False", "int8 qk failed to run")) + + qk_choice = "auto" + qk_reason = "resolves to int8; uint8 remaps to int8" + fp8qk_ms, fp8qk_err = measured(results, "fp8qk") + if fp8qk_ms and int8_ms: + qk_compare = f"float8 qk measured x{int8_ms / fp8qk_ms:.2f} vs int8" + if fp8qk_err and int8_err: + qk_compare += f", error {fp8qk_err:.5f} vs {int8_err:.5f}" + if fp8qk_ms < int8_ms * 0.95 and not (fp8qk_err and int8_err and fp8qk_err > int8_err * recommend_error_cap): + qk_choice = "float8_e4m3fn" + qk_reason = qk_compare + else: + qk_reason += f"; {qk_compare}" + elif fp8_result["qk"][0]: + qk_reason += "; float8 compiles here but was not benchmarked at this shape" + rows.append(("MatMul type", current("sdnq_attention_matmul_type"), qk_choice, qk_reason)) + + int8pv_ms, int8pv_err = measured(results, "int8pv") + fp8pv_ms, fp8pv_err = measured(results, "fp8pv") + pv_measured = [(dtype, name, ms, err) for dtype, name, ms, err in [("float8_e4m3fn", "fp8", fp8pv_ms, fp8pv_err), ("int8", "int8", int8pv_ms, int8pv_err)] if ms] + best_pv = min(pv_measured, key=lambda item: item[2]) if pv_measured else None + if best_pv and int8_ms and best_pv[2] < int8_ms * 0.95: + pv_dtype, pv_name, pv_ms, pv_err = best_pv + if pv_err and int8_err and pv_err > int8_err * recommend_error_cap: + rows.append(("PV MatMul type", current("sdnq_attention_pv_matmul_type"), "auto", f"{pv_name} pv is x{int8_ms / pv_ms:.2f} faster but multiplies error x{pv_err / int8_err:.1f}; auto keeps pv unquantized")) + else: + pv_reason = f"{pv_name} pv measured x{int8_ms / pv_ms:.2f} over int8 qk alone" + if pv_err and int8_err: + pv_reason += f", error {pv_err:.5f} vs {int8_err:.5f}" + rows.append(("PV MatMul type", current("sdnq_attention_pv_matmul_type"), pv_dtype, pv_reason)) + else: + pv_note = f"auto keeps pv unquantized; {' and '.join(name for _dtype, name, _ms, _err in pv_measured)} pv measured no gain here" if pv_measured else "auto keeps pv unquantized" + rows.append(("PV MatMul type", current("sdnq_attention_pv_matmul_type"), "auto", pv_note)) + + smooth_ms, smooth_err = measured(results, "smooth") + if smooth_ms and int8_ms and int8_err and smooth_err: + cost = smooth_ms / int8_ms - 1.0 + gain = int8_err / smooth_err if smooth_err > 0 else 1.0 + recommend = gain >= 1.3 and cost <= 0.25 # attention-level cost is a few percent end to end + rows.append(("Use Smooth K", current("sdnq_attention_smooth_k"), str(recommend), f"int8 error x{gain:.1f} lower for {cost:+.0%} time")) + + hadamard_ms, hadamard_err = measured(results, "hadamard") + if hadamard_ms and int8_ms and int8_err and hadamard_err: + cost = hadamard_ms / int8_ms - 1.0 + gain = int8_err / hadamard_err if hadamard_err > 0 else 1.0 + if gain >= 1.3 and cost <= 0.15: + rows.append(("Use Hadamard", current("sdnq_attention_use_hadamard"), "True", f"int8 error x{gain:.1f} lower for {cost:+.0%} time; hangs torch compile on non pow2 head dims (SD 1.5)")) + else: + rows.append(("Use Hadamard", current("sdnq_attention_use_hadamard"), "False", f"error x{gain:.1f} lower but {cost:+.0%} time; consider for long-sequence sessions; hangs torch compile on non pow2 head dims (SD 1.5)")) + + rows.append(("Hadamard Group Size", current("sdnq_attention_hadamard_group_size"), "256", "values above head dim are clamped; non pow2 values floor to the nearest power of 2")) + + differing = 0 + for setting, current_value, recommended, reason in rows: + if current_value == recommended: + table.add_row(setting, f"[green]{current_value}[/green]", recommended, reason) + else: + differing += 1 + table.add_row(setting, f"[yellow]{current_value}[/yellow]", recommended, reason) + emit(table) + if differing == 1: + emit("[yellow]1 setting differs from the recommended value, change it in Compute Settings -> SDNQ Attention[/yellow]") + elif differing: + emit(f"[yellow]{differing} settings differ from the recommended values, change them in Compute Settings -> SDNQ Attention[/yellow]") + else: + emit("[green]current settings already match the recommendations[/green]") + if not use_quantized: + emit("[dim]matmul type, pv matmul type, smooth k and hadamard only take effect when quantized matmul is enabled; their rows show what to pick if you enable it[/dim]") + + notes = [] + labels = {config_id: label for config_id, label, _kwargs in bench_configs} + best_id = best_config(results) + if base_ms and best_id is not None: + best_ms = results[best_id]["ms"] + if best_ms < base_ms * 0.95: + notes.append(f"sdnq attention is worth enabling on this gpu: {labels[best_id]} measured x{base_ms / best_ms:.2f} vs torch sdpa at {reference}") + else: + notes.append(f"[yellow]sdnq attention measured no speedup over torch sdpa on this gpu (best: {labels[best_id]} at x{base_ms / best_ms:.2f}); the sdp override costs performance here[/yellow]") + # the individual setting rows above compose into one config; cite it as actually measured + full_ms, full_err = measured(results, "full") + if full_ms and base_ms and int8_ms: + stack_note = f"all options on together (smooth k + hadamard + int8 pv over int8 qk) measured x{base_ms / full_ms:.2f} vs torch sdpa" + if full_err is not None: + stack_note += f", error {full_err:.5f}" + if int8_err is not None: + stack_note += f"; int8 qk alone x{base_ms / int8_ms:.2f}, error {int8_err:.5f}" + notes.append(stack_note) + if prep_status == "failing_dynamic": + notes.append("[red]the current environment fails at generation: torch compile cannot build the dynamic-shape input prep; numbers above were measured with the SDNQ_COMPILE_KWARGS='{\"dynamic\": false}' workaround applied, set it (verified working here) or install msvc build tools[/red]") + elif prep_status == "failing": + notes.append("[red]the current environment fails at generation: torch compile is broken; numbers above were measured with eager input prep, matching what you get after disabling Dequantize using torch.compile; alternatively install msvc build tools[/red]") + if not fp8_result["qk"][0]: + if fp8_failure_is_capability(fp8_result["qk"][1]): + notes.append("[red]float8_e4m3fn is unsupported on this gpu: selecting it in either dropdown fails generation with a compile error[/red]") + else: + notes.append("[red]float8_e4m3fn failed to compile in this environment: selecting it in either dropdown fails generation[/red]; the error is not the hardware-capability signature, so the fp8 rows above are missing for a torch or triton reason, not a gpu one") + sage_ms, _sage_err = measured(results, "sage") + if sage_ms and int8_ms: + notes.append(f"sageattention comparison at {reference}: sdnq int8 {int8_ms:.2f} ms vs sage {sage_ms:.2f} ms; sdnq additionally covers masks, gqa and causal attention") + sagefp16_ms, _sagefp16_err = measured(results, "sagefp16") + if sagefp16_ms: + notes.append("sage fp16 accum is a benchmark-only baseline: no sdnext setting reaches it (sage is pinned to fp32 accumulation on sm86 and sage's own dispatch never selects fp16 accum elsewhere)") + amdflash_ms, _amdflash_err = measured(results, "amdflash") + if amdflash_ms and int8_ms: + notes.append(f"triton flash comparison at {reference}: sdnq int8 {int8_ms:.2f} ms vs triton flash {amdflash_ms:.2f} ms; sdnq additionally covers masks and its gain depends on this gpu's int8 throughput") + # cross-reference the combined block section when it ran in this invocation: kernel-scope + # error buybacks can vanish at block output, and per-call costs differ inside a real block + block_results = report.get("block", {}).get("results", {}) + block_base = block_results.get("int8-mm-atten") or {} + if block_base.get("err") and block_base.get("ms"): + cross_parts = [] + buyback_seen = False + for variant_key, setting_name in (("int8-mm-smooth", "smooth k"), ("int8-mm-hadamard", "hadamard"), ("int8-mm-atten-full", "full stack (smooth + hadamard + int8 pv)")): + variant_entry = block_results.get(variant_key) or {} + if variant_entry.get("err") and variant_entry.get("ms"): + cross_parts.append(f"{setting_name} output error {variant_entry['err']:.5f} vs {block_base['err']:.5f} at {variant_entry['ms'] - block_base['ms']:+.2f} ms per block") + if variant_entry["err"] < block_base["err"] * 0.98: + buyback_seen = True + if cross_parts: + cross_note = f"block-level cross-check vs plain int8 attention: {'; '.join(cross_parts)}" + if not buyback_seen: + cross_note += "; the kernel-scope error buybacks above did not change block output error at this image shape" + notes.append(cross_note) + notes.append("* marks the best config per shape: lowest error among rows within 5% of the fastest sdnq time") + notes.append("the int8 qk row is what default settings run: MatMul type auto resolves to int8 and pv stays unquantized") + notes.append("the prep column is time spent quantizing q/k/v before the attention kernel, included in median time; it shrinks where torch compile can fuse it") + notes.append("[yellow]non pow2 head dims (sd 1.5): quantized matmul configs currently fail torch compile and hadamard hangs it; disable quantized matmul for sd 1.5 sessions or set SDNQ_COMPILE_KWARGS='{\"dynamic\": false}'[/yellow]") + notes.append("the six settings above apply on the next generation; toggling the 'SDNQ attention' SDP override requires a restart") + notes.append("errors are measured on synthetic tensors with outlier-heavy keys; real models, especially qk-normed dits, sit lower") + emit(Panel("\n".join(notes), title="notes", box=ROUNDED_BOX)) + report["recommendations_attention"] = dict(reference=reference, rows=[list(row) for row in rows], notes=notes) + + +def ratio_text(numerator_ms, denominator_ms): + if not numerator_ms or not denominator_ms: + return None + return f"x{numerator_ms / denominator_ms:.2f}" + + +def build_dequant_recommendations(dequant_results, weight_dequant_result, variant_results=None, float_mm_results=None, sweep_results=None): + reference = None + for shape_label, _out_features, _in_features in dequant_shapes: + results = dequant_results.get(shape_label) + if results and results.get("int8", {}).get("eager_ms") is not None: + reference = shape_label + break + if reference is None: + emit("[yellow]no successful dequant benchmark, sdnq recommendations unavailable[/yellow]") + return + results = dequant_results[reference] + base_ms = results.get("bf16", {}).get("fwd_ms") + + def entry(dtype_id): + return results.get(dtype_id) or {} + + def current(key): + return str(getattr(shared.opts, key)) + + table = Table(title=f"recommended settings (Compute Settings -> SDNQ), measured at the {reference} layer", box=ROUNDED_BOX) + table.add_column("setting") + table.add_column("current", justify="center") + table.add_column("recommended", justify="center") + table.add_column("reason") + + rows = [] + int8_eager, int8_compiled = entry("int8").get("eager_ms"), entry("int8").get("compiled_ms") + if int8_eager and int8_compiled: + recommend_compile = int8_compiled <= int8_eager * 0.90 + compile_reason = f"int8 dequant measured {ratio_text(int8_eager, int8_compiled)} compiled vs eager" + fwd_eager, fwd_compiled = entry("int8").get("fwd_eager_ms"), entry("int8").get("fwd_compiled_ms") + if fwd_eager and fwd_compiled: + compile_reason += f"; layer forward {fwd_compiled:.3f} vs {fwd_eager:.3f} ms" + rows.append(("Dequantize using torch.compile", current("sdnq_dequantize_compile"), str(recommend_compile), compile_reason)) + elif int8_eager: + rows.append(("Dequantize using torch.compile", current("sdnq_dequantize_compile"), current("sdnq_dequantize_compile"), "compiled int8 dequant unavailable, keeping the current value")) + + # judge quantized matmul on the dtype the current config would quantize with, falling back to int8; + # speed never wins alone: the faster path must also hold output error within recommend_error_cap + weights_mode = str(getattr(shared.opts, "sdnq_quantize_weights_mode", "int8")) + mode_ids = {cfg["weights_dtype"]: dtype_id for dtype_id, _label, cfg in dequant_dtype_configs} + mm_id = mode_ids.get(weights_mode, "int8") + mm_entry = entry(mm_id) + # explicit MatMul type rows are measured at the first dequant shape only; ignore them when + # the recommendation reference fell back to another shape + float_mm = float_mm_results if (float_mm_results and reference == dequant_shapes[0][0]) else {} + + def float_mm_entry(dtype_id, mm_dtype): + return float_mm.get(f"{dtype_id}+{mm_dtype}") or {} + + # candidate MatMul types for the current dtype: auto plus any measured explicit alternative + mm_candidates = [] + if mm_entry.get("mm_ms"): + mm_candidates.append(("auto", mm_entry.get("mm_dtype"), mm_entry["mm_ms"], mm_entry.get("mm_err"))) + if mm_id in float_mm_dtypes: + for alt_dtype in float_mm_alternative_dtypes: + alt = float_mm_entry(mm_id, alt_dtype) + if alt.get("mm_ms"): + mm_candidates.append((alt_dtype, alt.get("mm_dtype"), alt["mm_ms"], alt.get("mm_err"))) + if mm_candidates and mm_entry.get("fwd_ms"): + fastest_mm = min(ms for _sel, _res, ms, _err in mm_candidates) + near_fastest = [c for c in mm_candidates if c[2] <= fastest_mm * 1.05] + best_sel, best_resolved, best_ms, best_err = min(near_fastest, key=lambda c: c[3] if c[3] is not None else float("inf")) + fwd_err = mm_entry.get("fwd_err") + err_ok = not (fwd_err and best_err) or best_err <= fwd_err * recommend_error_cap + faster = best_ms <= mm_entry["fwd_ms"] * 0.90 + recommend_mm = faster and err_ok + mm_reason = f"{mm_id} quantized matmul ({best_resolved}) measured {ratio_text(mm_entry['fwd_ms'], best_ms)} vs the dequant path" + if fwd_err and best_err: + mm_reason += f", output error {best_err:.5f} vs {fwd_err:.5f}" + if faster and not err_ok: + mm_reason += f"; not recommended, the speedup multiplies output error beyond x{recommend_error_cap:.0f}" + if best_sel != "auto": + mm_reason += f"; measured with MatMul type {best_sel}" if mm_entry.get("mm_ms") else f"; needs MatMul type {best_sel}, auto (float8_e4m3fn) failed on this gpu" + if weights_mode not in mode_ids: + mm_reason += f"; current quantization type {weights_mode} was not benchmarked, judged on int8" + rows.append(("Use quantized MatMul", current("sdnq_use_quantized_matmul"), str(recommend_mm), mm_reason)) + + type_parts = [] + for sel, resolved, ms, err in mm_candidates: + sel_label = f"auto ({resolved})" if sel == "auto" else sel + type_parts.append(f"{sel_label} {ms:.3f} ms err {err:.5f}" if err is not None else f"{sel_label} {ms:.3f} ms") + if len(mm_candidates) > 1: + type_reason = f"lowest error within 5% of the fastest for {mm_id} weights: {', '.join(type_parts)}" + elif best_sel == "auto": + type_reason = f"auto resolves to {best_resolved} for {mm_id} weights" + else: + type_reason = f"auto (float8_e4m3fn) failed on this gpu for {mm_id} weights; {', '.join(type_parts)}" + rows.append(("Quantized MatMul type", current("sdnq_quantize_matmul_mode"), best_sel, type_reason)) + + sweeps = sweep_results or {} + sweeps_at_reference = reference == dequant_shapes[0][0] + mm_on = str(getattr(shared.opts, "sdnq_use_quantized_matmul", False)) == "True" + + # Group size: judged on the path the current config runs (mm cells when quantized matmul + # is on); an explicit size must cut error meaningfully without real speed or size cost + groups = sweeps.get("groups") or {} + group_id = mm_id if mm_id in group_sweep_dtypes else "int8" + auto_group = groups.get(f"{group_id}@0") or {} + if sweeps_at_reference and auto_group: + def group_metrics(g_entry): + ms = g_entry.get("mm_ms") if mm_on else g_entry.get("fwd_ms") + err = g_entry.get("mm_err") if mm_on else g_entry.get("weight_err") + return ms, err + auto_ms, auto_err = group_metrics(auto_group) + candidates = [] + for group in group_sweep_values: + if group == 0: + continue + g_entry = groups.get(f"{group_id}@{group}") or {} + g_ms, g_err = group_metrics(g_entry) + if g_ms and g_err and g_entry.get("size_bytes"): + candidates.append((group, g_ms, g_err, g_entry["size_bytes"])) + if auto_ms and auto_err and auto_group.get("size_bytes"): + qualifying = [c for c in candidates if c[2] < auto_err * 0.80 and c[1] <= auto_ms * 1.05 and c[3] <= auto_group["size_bytes"] * 1.10] + resolved = auto_group.get("mm_resolved") if mm_on else auto_group.get("resolved") + if qualifying: + best_group, best_gms, best_gerr, best_gsize = min(qualifying, key=lambda c: c[2]) + group_reason = f"{group_id} error {best_gerr:.5f} vs {auto_err:.5f} at auto ({resolved}), {best_gms:.3f} vs {auto_ms:.3f} ms, {size_cell(best_gsize).strip()} vs {size_cell(auto_group['size_bytes']).strip()}" + rows.append(("Group size", current("sdnq_group_size"), str(best_group), group_reason)) + else: + explicit_best = min(candidates, key=lambda c: c[2]) if candidates else None + group_reason = f"auto resolves to {resolved} for {group_id} weights" + if mm_on and explicit_best and auto_err and abs(explicit_best[2] - auto_err) <= auto_err * 0.10: + group_reason += f"; grouped storage is re-quantized per forward for quantized matmul, so no swept group changed mm error (best {explicit_best[2]:.5f} vs {auto_err:.5f})" + elif explicit_best: + group_reason += f"; best explicit ({explicit_best[0]}) measured error {explicit_best[2]:.5f} vs {auto_err:.5f} at {explicit_best[1]:.3f} vs {auto_ms:.3f} ms and {size_cell(explicit_best[3]).strip()} vs {size_cell(auto_group['size_bytes']).strip()}" + rows.append(("Group size", current("sdnq_group_size"), "0", group_reason)) + + # Dequantize using full precision: off keeps scales in the model dtype; the speed gain + # must hold error within the cap to be recommended + toggles = sweeps.get("toggles") or {} + fp32_off = toggles.get("fp32_off") or {} + toggle_id = mm_id if mm_id in toggle_dtypes else "int8" + off_entry = fp32_off.get(toggle_id) or {} + on_entry = entry(toggle_id) + if sweeps_at_reference and off_entry.get("fwd_ms") and on_entry.get("fwd_ms") and off_entry.get("weight_err") and on_entry.get("weight_err"): + off_faster = off_entry["fwd_ms"] <= on_entry["fwd_ms"] * 0.95 + off_err_ok = off_entry["weight_err"] <= on_entry["weight_err"] * recommend_error_cap + recommend_fp32 = not (off_faster and off_err_ok) + fp32_reason = f"{toggle_id} with full precision off: {off_entry['fwd_ms']:.3f} vs {on_entry['fwd_ms']:.3f} ms, weight error {off_entry['weight_err']:.5f} vs {on_entry['weight_err']:.5f}" + rows.append(("Dequantize using full precision", current("sdnq_dequantize_fp32"), str(recommend_fp32), fp32_reason)) + + # conv settings: the conv matmul verdict is spatial-size dependent, so every measured conv + # shape weighs in; the recommended value follows the first (unet-class) shape, with the + # other shape's number in the reason so vae-quantizing sessions can differ + conv_all = sweeps.get("conv") or {} + conv_per_shape = {} + for conv_shape_label, _oc, _ic, _k, _px in conv_shapes: + shape_conv = conv_all.get(conv_shape_label) or {} + mm_rows_here = [(config_id, shape_conv.get(config_id) or {}) for config_id in ("int8-mm", "uint8-mm")] + conv_per_shape[conv_shape_label] = (shape_conv.get("bf16") or {}, shape_conv.get("int8") or {}, [(config_id, row) for config_id, row in mm_rows_here if row.get("fwd_ms")]) + conv_base, conv_int8, conv_mm_rows = conv_per_shape.get(conv_shapes[0][0], ({}, {}, [])) + if conv_base.get("fwd_ms"): + quant_rows = [(config_id, row) for config_id, row in [("int8", conv_int8)] + conv_mm_rows if row.get("fwd_ms")] + if quant_rows: + best_conv_id, best_conv = min(quant_rows, key=lambda item: item[1]["fwd_ms"]) + conv_free = best_conv["fwd_ms"] <= conv_base["fwd_ms"] * 1.05 + conv_reason = f"{best_conv_id} conv measured {best_conv['fwd_ms']:.3f} vs {conv_base['fwd_ms']:.3f} ms {dtype_label()} at {conv_shapes[0][0]}, output error {best_conv.get('out_err', 0):.5f} vs {conv_base.get('out_err', 0):.5f}, size {size_cell(best_conv.get('size_bytes', 0)).strip()} vs {size_cell(conv_base.get('size_bytes', 0)).strip()}" + if not conv_free: + conv_reason += "; enable for the size saving, not speed" + rows.append(("Quantize convolutional layers", current("sdnq_quantize_conv_layers"), str(conv_free), conv_reason)) + if conv_int8.get("fwd_ms") and conv_mm_rows: + best_mm_id, best_mm = min(conv_mm_rows, key=lambda item: item[1]["fwd_ms"]) + mm_faster = best_mm["fwd_ms"] <= conv_int8["fwd_ms"] * 0.90 + mm_err_ok = not (best_mm.get("out_err") and conv_int8.get("out_err")) or best_mm["out_err"] <= conv_int8["out_err"] * recommend_error_cap + conv_mm_reason = f"{best_mm_id} measured {best_mm['fwd_ms']:.3f} vs {conv_int8['fwd_ms']:.3f} ms for the int8 conv dequant path at {conv_shapes[0][0]}, output error {best_mm.get('out_err', 0):.5f} vs {conv_int8.get('out_err', 0):.5f}" + other_base, _other_int8, other_mm_rows = conv_per_shape.get(conv_shapes[1][0], ({}, {}, [])) if len(conv_shapes) > 1 else ({}, {}, []) + if other_base.get("fwd_ms") and other_mm_rows: + other_best_id, other_best = min(other_mm_rows, key=lambda item: item[1]["fwd_ms"]) + conv_mm_reason += f"; at {conv_shapes[1][0]} {other_best_id} measured {ratio_text(other_base['fwd_ms'], other_best['fwd_ms'])} vs the {dtype_label()} conv" + if other_best["fwd_ms"] > other_base["fwd_ms"] * 1.05: + conv_mm_reason += ", a slowdown; disable when quantizing vae-class convs" + rows.append(("Use quantized MatMul with conv", current("sdnq_use_quantized_matmul_conv"), str(mm_faster and mm_err_ok), conv_mm_reason)) + + differing = 0 + for setting, current_value, recommended, reason in rows: + if current_value == recommended: + table.add_row(setting, f"[green]{current_value}[/green]", recommended, reason) + else: + differing += 1 + table.add_row(setting, f"[yellow]{current_value}[/yellow]", recommended, reason) + emit(table) + if differing: + emit(f"[yellow]{differing} setting{'s' if differing > 1 else ''} differ{'' if differing > 1 else 's'} from the recommended value, change in Compute Settings -> SDNQ[/yellow]") + elif rows: + emit("[green]current settings already match the recommendations[/green]") + + notes = [] + speedups = [] + for dtype_id, label, _cfg in dequant_dtype_configs: + text = ratio_text(entry(dtype_id).get("eager_ms"), entry(dtype_id).get("compiled_ms")) + if text: + speedups.append(f"{label} {text}") + if speedups: + notes.append(f"compiled dequant speedup vs eager at {reference}: {', '.join(speedups)}") + fp8_entry, fp8sdnq_entry = entry("fp8"), entry("fp8sdnq") + if fp8_entry.get("compiled_ms") and fp8sdnq_entry.get("compiled_ms"): + notes.append(f"fp8 storage: native float8_e4m3fn compiled measured {ratio_text(fp8sdnq_entry['compiled_ms'], fp8_entry['compiled_ms'])} vs the float8_e4m3fn_sdnq uint8 view") + elif fp8sdnq_entry.get("compiled_ms") and fp8_entry.get("eager_ms"): + notes.append(f"fp8 storage on this gpu: float8_e4m3fn_sdnq (uint8 view) compiled measured {ratio_text(fp8_entry['eager_ms'], fp8sdnq_entry['compiled_ms'])} vs eager float8_e4m3fn dequant, the fallback when e4m3 cannot compile") + if weight_dequant_result is not None: + e5m2_ok = weight_dequant_result["float8_e5m2"][0] + e4m3_ok = weight_dequant_result["float8_e4m3fn"][0] + if not e4m3_ok and e5m2_ok: + notes.append("float8_e5m2 storage compiles on this gpu while float8_e4m3fn does not; a compile gate only needs to cover e4m3") + elif not e4m3_ok and not e5m2_ok: + notes.append("[yellow]neither fp8 storage dtype compiles on this gpu; both need the compile gate[/yellow]") + fp8_mm_failed = [dtype_id for dtype_id, _label, _cfg in dequant_dtype_configs if entry(dtype_id).get("mm_error") and entry(dtype_id).get("mm_dtype") == "float8_e4m3fn"] + if fp8_mm_failed: + notes.append(f"[yellow]quantized matmul auto-selected float8_e4m3fn for {', '.join(fp8_mm_failed)} and failed on this gpu; set MatMul type explicitly to use quantized matmul with float weight dtypes[/yellow]") + for dtype_id in fp8_mm_failed: + alt_parts = [] + for alt_dtype in float_mm_alternative_dtypes: + alt = float_mm_entry(dtype_id, alt_dtype) + if alt.get("mm_ms"): + part = f"{alt_dtype} mm {alt['mm_ms']:.3f} ms" + if alt.get("mm_err") is not None: + part += f" err {alt['mm_err']:.5f}" + alt_parts.append(part) + dequant_fwd, dequant_err = entry(dtype_id).get("fwd_ms"), entry(dtype_id).get("fwd_err") + if alt_parts and dequant_fwd: + base_part = f"dequant path {dequant_fwd:.3f} ms" + if dequant_err is not None: + base_part += f" err {dequant_err:.5f}" + notes.append(f"{dtype_id} with MatMul type set explicitly: {', '.join(alt_parts)}; {base_part}") + if base_ms and entry(mm_id).get("fwd_ms"): + notes.append(f"current quantization type {weights_mode}: the dequant-path forward costs {ratio_text(entry(mm_id)['fwd_ms'], base_ms)} vs a {dtype_label()} nn.Linear at {reference}") + # size/error frontier: the dtypes no other measured dtype beats on both axes at once + sized = [(dtype_id, e["size_bytes"], e["weight_err"]) for dtype_id, _label, _cfg in dequant_dtype_configs for e in [entry(dtype_id)] if e.get("size_bytes") and e.get("weight_err")] + frontier = sorted((c for c in sized if not any(o is not c and o[1] <= c[1] and o[2] <= c[2] for o in sized)), key=lambda c: c[1]) + if len(frontier) > 1: + notes.append(f"size/error frontier at {reference}: " + ", ".join(f"{dtype_id} {size_cell(size).strip()} err {err:.3f}" for dtype_id, size, err in frontier)) + if variant_results: + for variant_id, _cfg in dequant_variant_configs: + parts = [] + for dtype_id in dequant_variant_dtypes: + variant_entry = variant_results.get(f"{dtype_id}+{variant_id}") or {} + if variant_entry.get("err_ratio"): + parts.append(f"{dtype_id} err x{variant_entry['err_ratio']:.2f} for {quant_cell(variant_entry['quant_s']).strip()} quant") + if parts: + notes.append(f"{variant_id} vs plain quantization: {', '.join(parts)}") + groups_sweep = sweeps.get("groups") or {} + if groups_sweep and sweeps_at_reference: + group_parts = [] + mm_flat = True + for dtype_id in group_sweep_dtypes: + auto_g = groups_sweep.get(f"{dtype_id}@0") or {} + swept = [(group, groups_sweep.get(f"{dtype_id}@{group}") or {}) for group in group_sweep_values if group != 0] + swept = [(group, g_entry) for group, g_entry in swept if g_entry.get("weight_err")] + if auto_g.get("weight_err") and swept: + best_group, best_entry = min(swept, key=lambda item: item[1]["weight_err"]) + if best_entry.get("size_bytes") and auto_g.get("size_bytes"): + group_parts.append(f"{dtype_id} group {best_group} weight err x{best_entry['weight_err'] / auto_g['weight_err']:.2f} of auto for {size_cell(best_entry['size_bytes']).strip()} vs {size_cell(auto_g['size_bytes']).strip()}") + mm_errs = [g_entry["mm_err"] for _group, g_entry in swept if g_entry.get("mm_err")] + ([auto_g["mm_err"]] if auto_g.get("mm_err") else []) + if len(mm_errs) > 1 and max(mm_errs) > min(mm_errs) * 1.10: + mm_flat = False + if group_parts: + groups_note = "group size storage tradeoff (dequant path): " + ", ".join(group_parts) + if mm_flat: + groups_note += "; grouped storage is re-quantized per forward for quantized matmul, no swept group changed mm error" + notes.append(groups_note) + conv_note_all = sweeps.get("conv") or {} + conv_note_parts = [] + for conv_shape_label, _oc, _ic, _k, _px in conv_shapes: + shape_conv = conv_note_all.get(conv_shape_label) or {} + base_row = shape_conv.get("bf16") or {} + mm_here = [row for config_id in ("int8-mm", "uint8-mm") for row in [shape_conv.get(config_id) or {}] if row.get("fwd_ms")] + if base_row.get("fwd_ms") and mm_here: + best_here = min(mm_here, key=lambda row: row["fwd_ms"]) + conv_note_parts.append(f"{conv_shape_label} best conv mm {ratio_text(base_row['fwd_ms'], best_here['fwd_ms'])}") + if len(conv_note_parts) > 1: + notes.append(f"conv quantized matmul vs the {dtype_label()} conv by shape: " + "; ".join(conv_note_parts)) + te_shape = dequant_shapes[2][0] if len(dequant_shapes) > 2 else None + te_results = dequant_results.get(te_shape) or {} if te_shape else {} + te_int8 = te_results.get("int8") or {} + if te_int8.get("fwd_ms") and te_int8.get("mm_ms") and entry("int8").get("fwd_ms") and entry("int8").get("mm_ms"): + notes.append(f"text-encoder geometry ({te_shape}): int8 quantized mm {ratio_text(te_int8['fwd_ms'], te_int8['mm_ms'])} vs the dequant path, {ratio_text(entry('int8')['fwd_ms'], entry('int8')['mm_ms'])} at {reference}; the TE override dropdowns follow these numbers") + svd_sweep = sweeps.get("svd") or {} + if svd_sweep and sweeps_at_reference: + for dtype_id in svd_rank_sweep_dtypes: + parts = [] + for rank in svd_rank_sweep_values: + rank_entry = svd_sweep.get(f"{dtype_id}@{rank}") or {} + if rank_entry.get("err_ratio"): + parts.append(f"rank {rank} err x{rank_entry['err_ratio']:.2f} ({size_cell(rank_entry['size_bytes']).strip()})") + if parts: + notes.append(f"svd rank on {dtype_id}: {', '.join(parts)}") + hgroup_sweep = sweeps.get("hgroups") or {} + hgroup_parts = [f"group {hgroup} err x{hentry['err_ratio']:.2f}" for hgroup in hadamard_group_values for hentry in [hgroup_sweep.get(str(hgroup)) or {}] if hentry.get("err_ratio")] + if hgroup_parts and sweeps_at_reference: + notes.append(f"weight-side hadamard group size on int8: {', '.join(hgroup_parts)}") + dynamic_sweep = (sweeps.get("toggles") or {}).get("dynamic") or {} + dynamic_parts = [] + for requested in dynamic_quant_requests: + dyn_entry = dynamic_sweep.get(requested) or {} + if dyn_entry.get("chosen"): + dynamic_parts.append(f"{requested} -> {dyn_entry['chosen']}" + (f" err {dyn_entry['weight_err']:.3f}" if dyn_entry.get("weight_err") else "")) + if dynamic_parts: + notes.append(f"dynamic quantization on these synthetic weights (default loss thresholds): {', '.join(dynamic_parts)}") + cpu_quant_s = (sweeps.get("toggles") or {}).get("cpu_quant_s") + gpu_quant_s = (sweeps.get("toggles") or {}).get("gpu_quant_s") + if cpu_quant_s and gpu_quant_s: + notes.append(f"Quantize using GPU: one int8 layer at {dequant_shapes[0][0]} quantized in {quant_cell(gpu_quant_s).strip()} on gpu vs {quant_cell(cpu_quant_s).strip()} on cpu; scales linearly with layer count at load") + notes.append("weight err is the relative quantization error of the dequantized weight vs the fp32 original; forward outputs inherit it") + notes.append("errors are measured on synthetic weights with exaggerated outlier channels; rotation and svd gains are outlier-driven, so real models sit closer to plain quantization") + if notes: + emit(Panel("\n".join(notes), title="dequant notes", box=ROUNDED_BOX)) + report["recommendations_dequant"] = dict(reference=reference, rows=[list(row) for row in rows], notes=notes) + + +def save_report(path, args, sections, selected): + report["run"] = dict(timestamp=time.strftime("%Y-%m-%dT%H:%M:%S"), sections=sections, shapes=selected, iters=args.iters, warmup=args.warmup, dtype=dtype_label()) + with open(path, "w", encoding="utf-8") as fh: + json.dump(report, fh, indent=2, default=str) + console.print(f"structured results saved to {path}") + + +pending_outputs = None # set by main once arguments are validated, so a crash can still flush +outputs_written = False + + +def flush_outputs(): + # write --save/--json exactly once, from the normal path or the crash handler; partial + # results beat losing an hour-long run to a kernel fault in one config + global outputs_written # pylint: disable=global-statement + if outputs_written or pending_outputs is None: + return + outputs_written = True + if pending_outputs["save"]: + save_transcript(pending_outputs["save"]) + if pending_outputs["json"]: + save_report(pending_outputs["json"], pending_outputs["args"], pending_outputs["sections"], pending_outputs["selected"]) + + +def main(): + global bench_dtype # pylint: disable=global-statement + args = parse_cli() + sections = [s.strip().lower() for s in args.sections.split(",") if s.strip()] + unknown_sections = [s for s in sections if s not in all_sections] + if unknown_sections: + console.print(f"[red]unknown section(s): {', '.join(unknown_sections)}; available: {', '.join(all_sections)}[/red]") + sys.exit(1) + known_dtypes = [dtype_id for dtype_id, _label, _cfg in dequant_dtype_configs] + selected_dtypes = None if args.dequant_dtypes.strip().lower() == "all" else [s.strip() for s in args.dequant_dtypes.split(",") if s.strip()] + if selected_dtypes is not None: + unknown_dtypes = [s for s in selected_dtypes if s not in known_dtypes] + if unknown_dtypes: + console.print(f"[red]unknown dequant dtype(s): {', '.join(unknown_dtypes)}; available: {', '.join(known_dtypes)}[/red]") + sys.exit(1) + known_blocks = [config_id for config_id, _w, _mm, _a in block_configs] + selected_blocks = None if args.block_configs.strip().lower() == "all" else [s.strip() for s in args.block_configs.split(",") if s.strip()] + if selected_blocks is not None: + unknown_blocks = [s for s in selected_blocks if s not in known_blocks] + if unknown_blocks: + console.print(f"[red]unknown block config(s): {', '.join(unknown_blocks)}; available: {', '.join(known_blocks)}[/red]") + sys.exit(1) + known_variants = [variant_id for variant_id, _cfg in dequant_variant_configs] + variants_arg = args.dequant_variants.strip().lower() + if variants_arg == "all": + selected_variants = list(known_variants) + elif variants_arg == "none": + selected_variants = [] + else: + selected_variants = [s.strip() for s in args.dequant_variants.split(",") if s.strip()] + unknown_variants = [s for s in selected_variants if s not in known_variants] + if unknown_variants: + console.print(f"[red]unknown dequant variant(s): {', '.join(unknown_variants)}; available: {', '.join(known_variants)}, all, none[/red]") + sys.exit(1) + sweeps_arg = args.dequant_sweeps.strip().lower() + if sweeps_arg == "all": + selected_sweeps = list(all_dequant_sweeps) + elif sweeps_arg == "none": + selected_sweeps = [] + else: + selected_sweeps = [s.strip() for s in args.dequant_sweeps.split(",") if s.strip()] + unknown_sweeps = [s for s in selected_sweeps if s not in all_dequant_sweeps] + if unknown_sweeps: + console.print(f"[red]unknown dequant sweep(s): {', '.join(unknown_sweeps)}; available: {', '.join(all_dequant_sweeps)}, all, none[/red]") + sys.exit(1) + backends_arg = args.mm_backends.strip().lower() + if backends_arg in {"none", ""}: + selected_mm_backends = [] + elif backends_arg == "all": + selected_mm_backends = list(all_mm_backends) + else: + selected_mm_backends = [s.strip() for s in args.mm_backends.split(",") if s.strip()] + unknown_backends = [s for s in selected_mm_backends if s not in all_mm_backends] + if unknown_backends: + console.print(f"[red]unknown matmul backend(s): {', '.join(unknown_backends)}; available: {', '.join(all_mm_backends)}, all, none[/red]") + sys.exit(1) + if not load_sdnext(): + sys.exit(1) + if args.dtype == "auto": + # webui generation dtype: bf16 where native, fp16 on older gpus where bf16 is emulated + if isinstance(getattr(devices, "dtype", None), torch.dtype) and devices.dtype in (torch.bfloat16, torch.float16): + bench_dtype = devices.dtype + else: + bench_dtype = {"bf16": torch.bfloat16, "fp16": torch.float16}[args.dtype] + selected = list(full_run) if args.shapes.strip().lower() == "all" else [s.strip() for s in args.shapes.split(",") if s.strip()] + unknown = [s for s in selected if s not in shape_presets] + if unknown: + console.print(f"[red]unknown shape preset(s): {', '.join(unknown)}; available: {', '.join(shape_presets)}[/red]") + sys.exit(1) + global pending_outputs # pylint: disable=global-statement + pending_outputs = dict(save=args.save, json=args.json, args=args, sections=sections, selected=selected) + print_banner(selected, sections, args) + prep_status, prep_detail = probe_compiled_prep() # must run first: see the cold-start note in probe_compiled_prep + fp8_result = probe_fp8() if "attention" in sections else None + weight_dequant_result = probe_weight_dequant_compile() if "dequant" in sections else None + print_environment(fp8_result, prep_status, prep_detail, weight_dequant_result=weight_dequant_result) + if not args.skip_checks and "attention" in sections: + run_correctness() + if report.get("correctness_aborted_after") and not cuda_context_alive(): + flush_outputs() + sys.exit(1) + if args.skip_bench: + flush_outputs() + return + + dequant_results = {} + if "dequant" in sections: + if free_vram_gb() < 2.0: + emit(f"[yellow]skipping dequant benchmarks: needs about 2 gb free vram, {free_vram_gb():.1f} gb available[/yellow]") + else: + from modules.sdnq.common import check_torch_compile + if not check_torch_compile(): + # the module-level compiled dequant is a passthrough with the option off; swap in + # a real compiled variant so the compiled fwd rows measure what enabling it gives + from modules.sdnq import dequantizer as dequantizer_module + dequantizer_module.dequantize_weight_compiled = get_compiled_dequantize_weight() + emit("[yellow]Dequantize using torch.compile is off in the current config: compiled fwd rows are measured with a tool-compiled dequant, matching the webui after enabling it[/yellow]") + for index, (shape_label, out_features, in_features) in enumerate(dequant_shapes, start=1): + dequant_results[shape_label] = bench_dequant_shape(shape_label, out_features, in_features, args.iters, args.warmup, position=(index, len(dequant_shapes)), config_timeout=args.config_timeout, selected_dtypes=selected_dtypes) + torch_device_module.empty_cache() + variant_results = {} + if selected_variants: + first_label, first_out, first_in = dequant_shapes[0] + variant_results = bench_dequant_variants(first_label, first_out, first_in, dequant_results.get(first_label, {}), selected_dtypes, selected_variants, args.iters, args.warmup, config_timeout=args.config_timeout) + first_label, first_out, first_in = dequant_shapes[0] + first_results = dequant_results.get(first_label, {}) + float_mm_results = bench_float_mm_alternatives(first_label, first_out, first_in, first_results, selected_dtypes, args.iters, args.warmup, config_timeout=args.config_timeout) + if selected_mm_backends: + bench_mm_backends(first_label, first_out, first_in, selected_dtypes, selected_mm_backends, args.iters, args.warmup, config_timeout=args.config_timeout, rounds=args.mm_rounds) + sweep_results = {} + if "groups" in selected_sweeps: + sweep_results["groups"] = bench_group_sizes(first_label, first_out, first_in, first_results, selected_dtypes, args.iters, args.warmup, config_timeout=args.config_timeout) + if "svd" in selected_sweeps: + sweep_results["svd"] = bench_svd_ranks(first_label, first_out, first_in, first_results, selected_dtypes, args.iters, args.warmup, config_timeout=args.config_timeout) + if "hgroups" in selected_sweeps: + sweep_results["hgroups"] = bench_hadamard_groups(first_label, first_out, first_in, first_results, selected_dtypes, args.iters, args.warmup, config_timeout=args.config_timeout) + if "toggles" in selected_sweeps: + sweep_results["toggles"] = bench_quant_toggles(first_label, first_out, first_in, first_results, selected_dtypes, args.iters, args.warmup, config_timeout=args.config_timeout) + if "conv" in selected_sweeps: + sweep_results["conv"] = bench_conv_section(args.iters, args.warmup, config_timeout=args.config_timeout) + build_dequant_recommendations(dequant_results, weight_dequant_result, variant_results, float_mm_results, sweep_results) + + # the block section runs before the attention section: a broken-compile attention + # environment disables dynamo globally, which would poison the block compiles + if "block" in sections: + if free_vram_gb() < 3.0: + emit(f"[yellow]skipping block benchmarks: needs about 3 gb free vram, {free_vram_gb():.1f} gb available[/yellow]") + else: + bench_block_section(args.iters, args.warmup, config_timeout=args.config_timeout, selected=selected_blocks) + + if "attention" in sections: + # bench the prep mode the advice points to: compiled, static workaround, or eager + if prep_status == "failing_dynamic": + from modules.sdnq.kernels import triton_atten as atten_module + inner = getattr(atten_module.get_attn_inputs, "_torchdynamo_orig_callable", None) + atten_module.get_attn_inputs = torch.compile(inner, fullgraph=True, dynamic=False) + emit("[yellow]dynamic-shape compile is broken here: benchmarking with the dynamic=false workaround applied, numbers match the webui after setting SDNQ_COMPILE_KWARGS='{\"dynamic\": false}'[/yellow]") + elif prep_status == "failing": + emit("[yellow]torch compile is broken here: benchmarking with eager input prep, numbers match the webui after disabling Dequantize using torch.compile[/yellow]") + from modules.sdnq.kernels import triton_atten as atten_module + inner = getattr(atten_module.get_attn_inputs, "_torchdynamo_orig_callable", None) + if inner is not None: # swap in the eager prep; a disable toggle raises on torch 2.13+ + atten_module.get_attn_inputs = inner + all_results = {} + minimum_vram = {"wan22": 6.0, "wan22-cfg": 12.0, "ltx2": 3.0, "masked": 6.0} + for index, preset in enumerate(selected, start=1): + needed = minimum_vram.get(preset, 2.0) + if free_vram_gb() < needed: + emit(f"[yellow]skipping {preset}: needs about {needed:.0f} gb free vram, {free_vram_gb():.1f} gb available[/yellow]") + continue + all_results[preset] = bench_shape(preset, args.iters, args.warmup, position=(index, len(selected)), config_timeout=args.config_timeout, fp8_result=fp8_result) + build_recommendations(all_results, fp8_result, prep_status) + + flush_outputs() + + +if __name__ == "__main__": + try: + main() + except KeyboardInterrupt: + console.print("[yellow]interrupted, saving partial results[/yellow]") + flush_outputs() + sys.exit(130) + except Exception as main_error: # pylint: disable=broad-exception-caught + console.print(f"[red]benchmark aborted: {error_summary(main_error, 200)}[/red]") + if not cuda_context_alive(): + console.print("[red]the cuda context is corrupted (kernel faults are sticky); partial results saved, a rerun is required to continue[/red]") + flush_outputs() + raise diff --git a/data/previews.json b/data/previews.json index d9f65721e..8b607ef0c 100644 --- a/data/previews.json +++ b/data/previews.json @@ -1,41 +1,41 @@ { - "sd-v21-512-ema": "stabilityai--stable-diffusion-2-1-base.jpg", - "stable-diffusion-v1-5--stable-diffusion-v1-5": "v1-5-pruned-fp16-emaonly.jpg", - "stabilityai--stable-diffusion-xl-base-1.0": "stabilityai--stable-diffusion-xl-base-1.0.jpg", - "stabilityai--stable-diffusion-3-medium-diffusers": "stabilityai--stable-diffusion-3.jpg", - "stabilityai--stable-diffusion-3.5-medium": "stabilityai--stable-diffusion-3_5-medium.jpg", - "stabilityai--stable-diffusion-3.5-large": "stabilityai--stable-diffusion-3_5-large.jpg", - "stabilityai--stable-diffusion-3.5-large-turbo": "stabilityai--stable-diffusion-3_5-large-turbo.jpg", - "Disty0--FLUX.1-dev-qint8": "black-forest-labs--FLUX.1-dev.jpg", + "chroma-unlocked-v50-annealed": "lodestones--Chroma-annealed.jpg", + "chroma-unlocked-v50": "lodestones--Chroma-detail.jpg", "Disty0--FLUX.1-dev-qint4": "black-forest-labs--FLUX.1-dev.jpg", - "sayakpaul--flux.1-dev-nf4": "black-forest-labs--FLUX.1-dev.jpg", - "THUDM--CogVideoX-2b": "THUDM--CogView3-Plus-3B.jpg", - "THUDM--CogVideoX-5b": "THUDM--CogView3-Plus-3B.jpg", - "THUDM--CogVideoX-5b-I2V": "THUDM--CogView3-Plus-3B.jpg", + "Disty0--FLUX.1-dev-qint8": "black-forest-labs--FLUX.1-dev.jpg", "Efficient-Large-Model--Sana_1600M_1024px_BF16_diffusers": "Efficient-Large-Model--Sana_1600M_1024px_diffusers.jpg", "Efficient-Large-Model--Sana_1600M_2Kpx_BF16_diffusers": "Efficient-Large-Model--Sana_1600M_1024px_diffusers.jpg", "Efficient-Large-Model--Sana_1600M_4Kpx_BF16_diffusers": "Efficient-Large-Model--Sana_1600M_1024px_diffusers.jpg", "Efficient-Large-Model--Sana_600M_1024px_diffusers": "Efficient-Large-Model--Sana_1600M_1024px_diffusers.jpg", - "stabilityai--stable-video-diffusion-img2vid-xt-1-1": "stabilityai--stable-video-diffusion-img2vid-xt.jpg", - "shuttleai--shuttle-3-diffusion": "shuttleai--shuttle-3-diffusion.jpg", "HiDream-I1-Full": "HiDream-I1 Full", - "lodestones--Chroma1-Base": "lodestones--Chroma-Base.jpg", - "lodestones--Chroma1-HD": "lodestones--Chroma-HD.jpg", - "chroma-unlocked-v50": "lodestones--Chroma-detail.jpg", - "chroma-unlocked-v50-annealed": "lodestones--Chroma-annealed.jpg", - "vladmandic--Qwen-Lightning": "Qwen-Lightning.jpg", - "vladmandic--Qwen-Lightning-Edit": "Qwen-Lightning.jpg", - "Wan-AI--Wan2.2-T2V-A14B-Diffusers": "Wan-AI--Wan2.2-T2V-A14B-Diffusers.jpg", - "Wan-AI--Wan2.1-T2V-14B-Diffusers": "Wan-AI--Wan2.1-T2V-14B-Diffusers.jpg", - "linoyts--Wan2.2-VACE-Fun-14B-diffusers": "linoyts--Wan2.2-VACE-Fun-14B-diffusers.jpg", - "vladmandic--Anima-1.0-Base-sdnq-svd-dynamic-uint4": "vladmandic--Anima-1.0-Base.jpg", - "vladmandic--Anima-1.0-Turbo-sdnq-svd-dynamic-uint4": "vladmandic--Anima-1.0-Turbo.jpg", - "vladmandic--Krea-2-Turbo-sdnq-hadamard-uint4": "CalamitousFelicitousness--Krea-2-Turbo-Diffusers.jpg", - "vladmandic--Krea-2-Base-sdnq-hadamard-uint4": "CalamitousFelicitousness--Krea-2-Base-Diffusers.jpg", - "Jinstudio--Lens": "microsoft--Lens.jpg", "Jinstudio--Lens-Base": "microsoft--Lens-Base.jpg", "Jinstudio--Lens-Turbo": "microsoft--Lens-Turbo.jpg", + "Jinstudio--Lens": "microsoft--Lens.jpg", + "linoyts--Wan2.2-VACE-Fun-14B-diffusers": "linoyts--Wan2.2-VACE-Fun-14B-diffusers.jpg", + "lodestones--Chroma1-Base": "lodestones--Chroma-Base.jpg", + "lodestones--Chroma1-HD": "lodestones--Chroma-HD.jpg", "SahilCarterr--BRIA-3.2": "briaai--BRIA-3.2.jpg", + "sayakpaul--flux.1-dev-nf4": "black-forest-labs--FLUX.1-dev.jpg", + "sd-v21-512-ema": "stabilityai--stable-diffusion-2-1-base.jpg", + "shuttleai--shuttle-3-diffusion": "shuttleai--shuttle-3-diffusion.jpg", + "stabilityai--stable-diffusion-3-medium-diffusers": "stabilityai--stable-diffusion-3.jpg", + "stabilityai--stable-diffusion-3.5-large-turbo": "stabilityai--stable-diffusion-3_5-large-turbo.jpg", + "stabilityai--stable-diffusion-3.5-large": "stabilityai--stable-diffusion-3_5-large.jpg", + "stabilityai--stable-diffusion-3.5-medium": "stabilityai--stable-diffusion-3_5-medium.jpg", + "stabilityai--stable-diffusion-xl-base-1.0": "stabilityai--stable-diffusion-xl-base-1.0.jpg", + "stabilityai--stable-video-diffusion-img2vid-xt-1-1": "stabilityai--stable-video-diffusion-img2vid-xt.jpg", + "stable-diffusion-v1-5--stable-diffusion-v1-5": "v1-5-pruned-fp16-emaonly.jpg", + "THUDM--CogVideoX-2b": "THUDM--CogView3-Plus-3B.jpg", + "THUDM--CogVideoX-5b-I2V": "THUDM--CogView3-Plus-3B.jpg", + "THUDM--CogVideoX-5b": "THUDM--CogView3-Plus-3B.jpg", + "vladmandic--Anima-1.0-Base-Merge-sdnq-hadamard-uint4": "vladmandic--Anima-1.0-Base.jpg", + "vladmandic--Anima-1.0-Base-sdnq-svd-dynamic-uint4": "vladmandic--Anima-1.0-Base.jpg", + "vladmandic--Anima-1.0-Turbo-sdnq-svd-dynamic-uint4": "vladmandic--Anima-1.0-Turbo.jpg", "vladmandic--Flux.2-Klein-9B-KV-sdnq-hadamard-uint4": "black-forest-labs--FLUX.2-klein-9b-kv.jpg", - "vladmandic--Anima-1.0-Base-Merge-sdnq-hadamard-uint4": "vladmandic--Anima-1.0-Base.jpg" + "vladmandic--Krea-2-Base-sdnq-hadamard-uint4": "CalamitousFelicitousness--Krea-2-Base-Diffusers.jpg", + "vladmandic--Krea-2-Turbo-sdnq-hadamard-uint4": "CalamitousFelicitousness--Krea-2-Turbo-Diffusers.jpg", + "vladmandic--Qwen-Lightning-Edit": "Qwen-Lightning.jpg", + "vladmandic--Qwen-Lightning": "Qwen-Lightning.jpg", + "Wan-AI--Wan2.1-T2V-14B-Diffusers": "Wan-AI--Wan2.1-T2V-14B-Diffusers.jpg", + "Wan-AI--Wan2.2-T2V-A14B-Diffusers": "Wan-AI--Wan2.2-T2V-A14B-Diffusers.jpg" } diff --git a/data/reference-base.json b/data/reference-base.json index f8cb972b5..70c3d8b58 100644 --- a/data/reference-base.json +++ b/data/reference-base.json @@ -288,6 +288,14 @@ "date": "2026 May", "size": 4.99 }, + "Anima 1.0 Aesthetic": { + "path": "CalamitousFelicitousness/Anima-1.0-Aesthetic-Diffusers", + "preview": "CalamitousFelicitousness--Anima-1.0-Aesthetic-Diffusers.jpg", + "desc": "Anima 1.0 Aesthetic, fine-tuned for better consistency and a higher quality default art style. A 2B parameter anime-focused text-to-image model based on modified Cosmos-Predict-2B with Qwen3-0.6B text encoder, created by CircleStone Labs and Comfy Org.", + "extras": "sampler: Default, cfg_scale: 4.5, steps: 30", + "date": "2026 July", + "size": 4.99 + }, "Meituan LongCat Image": { "path": "meituan-longcat/LongCat-Image", "preview": "meituan-longcat--LongCat-Image.jpg", @@ -902,5 +910,13 @@ "size": 46.86, "extras": "sampler: Default", "date": "2026 April" + }, + "JoyAI Image Edit Plus": { + "path": "jdopensource/JoyAI-Image-Edit-Plus-Diffusers", + "preview": "jdopensource--JoyAI-Image-Edit-Diffusers.jpg", + "desc": "JoyAI Image Edit Plus is a Diffusers-native image editing model that combines a JoyImageEditPlus transformer with Qwen3-VL multimodal conditioning for instruction-guided edits.", + "size": 47.98, + "extras": "sampler: Default", + "date": "2026 July" } } diff --git a/data/reference-distilled.json b/data/reference-distilled.json index 2cbc44d3d..f1391ec63 100644 --- a/data/reference-distilled.json +++ b/data/reference-distilled.json @@ -212,10 +212,11 @@ "date": "2026 March" }, "Anima 1.0 Turbo": { - "path": "vladmandic/Anima-1.0-Turbo", - "preview": "vladmandic--Anima-1.0-Turbo.jpg", - "desc": "Anima 1.0 Turbo with extended 1024-resolution training and expanded dataset coverage for less common artists. A 2B parameter anime-focused text-to-image model based on modified Cosmos-Predict-2B with Qwen3-0.6B text encoder, created by CircleStone Labs and Comfy Org.", - "date": "2026 May", + "path": "CalamitousFelicitousness/Anima-1.0-Turbo-Diffusers", + "preview": "CalamitousFelicitousness--Anima-1.0-Turbo-Diffusers.jpg", + "desc": "Anima 1.0 Turbo, distilled for fast generation with increased stability and a strong default style. A 2B parameter anime-focused text-to-image model based on modified Cosmos-Predict-2B with Qwen3-0.6B text encoder, created by CircleStone Labs and Comfy Org.", + "extras": "sampler: Default, cfg_scale: 1.0, steps: 10", + "date": "2026 July", "size": 4.99 }, "Meituan LongCat Image-Edit Turbo": { diff --git a/extensions-builtin/sdnext-kanvas b/extensions-builtin/sdnext-kanvas index 4f650445b..0261cc283 160000 --- a/extensions-builtin/sdnext-kanvas +++ b/extensions-builtin/sdnext-kanvas @@ -1 +1 @@ -Subproject commit 4f650445b05487a350524debfa30e8340342c602 +Subproject commit 0261cc2830326cf573222fb6ae8b9597a45e69cc diff --git a/extensions-builtin/sdnext-modernui b/extensions-builtin/sdnext-modernui index 4b8d5f677..07890f0d7 160000 --- a/extensions-builtin/sdnext-modernui +++ b/extensions-builtin/sdnext-modernui @@ -1 +1 @@ -Subproject commit 4b8d5f67781b4fb33058ffda39dc4228eb2f98ee +Subproject commit 07890f0d7b1412634fb2bbde45f326b8b3760711 diff --git a/installer.py b/installer.py index 5ce533735..9f929913f 100644 --- a/installer.py +++ b/installer.py @@ -549,7 +549,7 @@ def check_diffusers(): t_start = time.time() if args.skip_all: return - target_commit = "ea802951f5fb235b6af8fe9247f56187d49748b2" # diffusers commit hash == 0.39.0.dev0 == 06-29-2026 + target_commit = "01969142b55379991fee07608c9e7e8f80afced0" # diffusers commit hash == 0.39.0.dev0 == 06-29-2026 # if args.use_rocm or args.use_zluda or args.use_directml: # sha = '043ab2520f6a19fce78e6e060a68dbc947edb9f9' # lock diffusers versions for now pkg = package_spec('diffusers') diff --git a/models/Reference/CalamitousFelicitousness--Anima-1.0-Aesthetic-Diffusers.jpg b/models/Reference/CalamitousFelicitousness--Anima-1.0-Aesthetic-Diffusers.jpg new file mode 100644 index 000000000..8e395499e Binary files /dev/null and b/models/Reference/CalamitousFelicitousness--Anima-1.0-Aesthetic-Diffusers.jpg differ diff --git a/models/Reference/CalamitousFelicitousness--Anima-1.0-Turbo-Diffusers.jpg b/models/Reference/CalamitousFelicitousness--Anima-1.0-Turbo-Diffusers.jpg new file mode 100644 index 000000000..87db38699 Binary files /dev/null and b/models/Reference/CalamitousFelicitousness--Anima-1.0-Turbo-Diffusers.jpg differ diff --git a/models/Reference/vladmandic--Anima-1.0-Turbo.jpg b/models/Reference/vladmandic--Anima-1.0-Turbo.jpg deleted file mode 100644 index 17830d5c5..000000000 Binary files a/models/Reference/vladmandic--Anima-1.0-Turbo.jpg and /dev/null differ diff --git a/modules/api/api.py b/modules/api/api.py index cc7f6befa..108d74fee 100644 --- a/modules/api/api.py +++ b/modules/api/api.py @@ -58,7 +58,7 @@ class Api: self.add_api_route("/sdapi/v1/restart", server.post_restart, methods=["POST"], status_code=204, tags=["Server"]) self.add_api_route("/sdapi/v1/memory", server.get_memory, methods=["GET"], response_model=models.ResMemory, tags=["Server"]) self.add_api_route("/sdapi/v1/cmd-flags", server.get_cmd_flags, methods=["GET"], response_model=models.FlagsModel, tags=["Server"]) - self.add_api_route("/sdapi/v1/gpu", gpu.get_gpu, methods=["GET"], tags=["Server"]) + self.add_api_route("/sdapi/v1/gpu", gpu.get_gpu, methods=["GET"], tags=["Server"], response_model=list[dict]) self.add_api_route("/sdapi/v1/gpu-smi", gpu.get_gpu_smi, methods=["GET"], response_model=list[models.ResGPU], tags=["Server"]) # core api using locking diff --git a/modules/api/gpu.py b/modules/api/gpu.py index 7e8c86142..f4916f088 100644 --- a/modules/api/gpu.py +++ b/modules/api/gpu.py @@ -7,12 +7,7 @@ device = None def get_gpu(): import installer - res = {} - if len(installer.gpu_info) == 1: - return installer.gpu_info[0] - for i, item in enumerate(installer.gpu_info): - res[i] = item - return res + return installer.gpu_info def get_gpu_smi(): diff --git a/modules/api/loras.py b/modules/api/loras.py index f3f155b33..1485cdcda 100644 --- a/modules/api/loras.py +++ b/modules/api/loras.py @@ -26,6 +26,12 @@ def post_refresh_loras(): return result +def get_loaded(): + """Return a list of currently loaded LoRA networks with name, alias, path, and metadata.""" + from modules.lora import lora_common + return [obj.name for obj in lora_common.loaded_networks] + + def _invalidate_extra_networks(): """Reset extra-networks page caches so the v2 API picks up changes.""" from modules import shared @@ -38,3 +44,4 @@ def register_api(api): api.add_api_route("/sdapi/v1/lora", get_lora, methods=["GET"], response_model=dict, tags=["Enumerators"]) api.add_api_route("/sdapi/v1/loras", get_loras, methods=["GET"], response_model=list[dict], tags=["Enumerators"]) api.add_api_route("/sdapi/v1/refresh-loras", post_refresh_loras, methods=["POST"], tags=["Functional"]) + api.add_api_route("/sdapi/v1/loaded-loras", get_loaded, methods=["GET"], response_model=list[str], tags=["Enumerators"]) diff --git a/modules/api/middleware.py b/modules/api/middleware.py index f0dee3682..582369268 100644 --- a/modules/api/middleware.py +++ b/modules/api/middleware.py @@ -9,6 +9,7 @@ import fastapi from starlette.responses import JSONResponse from fastapi import FastAPI, Request, Response from fastapi.exceptions import HTTPException +from fastapi.responses import RedirectResponse from fastapi.encoders import jsonable_encoder from modules.logger import log import modules.errors as errors @@ -17,6 +18,19 @@ from modules.api.validate import validate_request, validate_log errors.install() +def validate_subpath(endpoint: str, subpath: str | None): + if (subpath is not None) and (len(subpath) > 0) and (not endpoint.startswith(subpath)): + if not subpath.endswith('/'): + subpath = f'{subpath}/' + if endpoint.startswith('/'): + url = f'{subpath}{endpoint[1:]}' + else: + url = f'{subpath}{endpoint}' + log.trace(f'API: redirect subpath={subpath} url="{endpoint}" redirect="{url}"') + return RedirectResponse(url=url, status_code=308) + return None + + def setup_middleware(app: FastAPI, cmd_opts): ssl._create_default_https_context = ssl._create_unverified_context # pylint: disable=protected-access uvicorn_logger=logging.getLogger("uvicorn.error") @@ -43,6 +57,11 @@ def setup_middleware(app: FastAPI, cmd_opts): endpoint = req.scope.get('path', 'err') client = req.scope.get('client', ('0:0.0.0', 0))[0] token = req.cookies.get("access-token") or req.cookies.get("access-token-unsecure") + + redirect = validate_subpath(endpoint, cmd_opts.subpath) + if redirect: + return redirect + validate_request(client, endpoint) if cmd_opts.api_log: if not validate_log(client, endpoint): diff --git a/modules/api/validate.py b/modules/api/validate.py index 552aa95a7..5a3755cc3 100644 --- a/modules/api/validate.py +++ b/modules/api/validate.py @@ -31,6 +31,7 @@ log_cost = { "/sdapi/v1/memory": -1, "/sdapi/v1/platform": -1, "/sdapi/v1/checkpoint": -1, + "/sdapi/v1/loaded-loras": -1, "/sdapi/v1/gpu-smi": -1, "/sdapi/v1/status": 60, "/sdapi/v1/progress": 60, @@ -38,8 +39,9 @@ log_cost = { log_exclude_suffix = ['.css', '.js', '.ico', '.svg'] log_exclude_prefix = ['/assets'] + class Limiter(): - def __init__(self, limit): + def __init__(self, limit, subpath=None): import limits self.request_backend = limits.storage.MemoryStorage() self.request_limit = limit # default is 300 requests per minute @@ -50,7 +52,8 @@ class Limiter(): self.log_strategy = limits.strategies.FixedWindowRateLimiter(self.log_backend) self.log_limiter = limits.parse(f"{self.log_limit}/minute") self.summary = {} - log.info(f'API: limit={self.request_limit} strategy={self.request_strategy.__class__.__name__} backend={self.request_backend.__class__.__name__}') + self.subpath = subpath + log.info(f'API: limit={self.request_limit} strategy={self.request_strategy.__class__.__name__} backend={self.request_backend.__class__.__name__} subpath={self.subpath}') def stats(self): @@ -66,8 +69,8 @@ class Limiter(): return False status = self.request_strategy.hit(self.request_limiter, client, api, cost=cost) if not status and not quiet: - log.warning(f'API: client={client} api={api} rate limit exceeded') from fastapi.exceptions import HTTPException + log.warning(f'API: client={client} api={api} rate limit exceeded') raise HTTPException(status_code=429, detail=f"{client}:{api}: rate limit exceeded") return status @@ -85,7 +88,7 @@ class Limiter(): return status -limiter = Limiter(300) +limiter = Limiter(0, None) def get_api_stats(): @@ -94,20 +97,21 @@ def get_api_stats(): def validate_request(client, endpoint): global limiter # pylint: disable=global-statement - from modules.shared import opts + from modules.shared import opts, cmd_opts if opts.server_rate_limit != limiter.request_limit: - limiter = Limiter(opts.server_rate_limit) + limiter = Limiter(opts.server_rate_limit, cmd_opts.subpath) api = re.match(r"^[^?#&=]+", endpoint).group(0) + + if (limiter.subpath is not None) and (len(limiter.subpath) > 0) and api.startswith(limiter.subpath): # strip subpath from api for rate limiting + api = api[len(limiter.subpath):] key = f"{client}:{api}" if key not in limiter.summary: limiter.summary[key] = 0 limiter.summary[key] += 1 - # import anyio - # _limiter = anyio.to_thread.current_default_thread_limiter() - # log.debug(f'FastAPI: threads={_limiter._total_tokens}') return limiter.check_request(client, api) - def validate_log(client, endpoint): api = re.match(r"^[^?#&=]+", endpoint).group(0) + if (limiter.subpath is not None) and (len(limiter.subpath) > 0) and api.startswith(limiter.subpath): # strip subpath from api for logging + api = api[len(limiter.subpath):] return limiter.check_log(client, api) diff --git a/modules/attention.py b/modules/attention.py index 9a1f8e114..00456d871 100644 --- a/modules/attention.py +++ b/modules/attention.py @@ -24,7 +24,11 @@ def set_sdnq_attention(): sdpa_pre_sdnq_atten = torch.nn.functional.scaled_dot_product_attention @wraps(sdpa_pre_sdnq_atten) def sdpa_sdnq_atten(query: torch.FloatTensor, key: torch.FloatTensor, value: torch.FloatTensor, attn_mask: torch.Tensor | None = None, dropout_p: float = 0.0, is_causal: bool = False, scale: float | None = None, enable_gqa: bool = False, **kwargs) -> torch.FloatTensor: - if query.device.type != "cpu" and query.shape[-3] > 1: # Skip VAE + if ( + query.device.type != "cpu" + and (query.shape[-2] >= 512 or key.shape[-2] >= 512) # Skip TE + and query.shape[-3] > 1 # Skip VAE + ): return sdnq_triton_atten( query=query, key=key, value=value, attn_mask=attn_mask, is_causal=is_causal, scale=scale, enable_gqa=enable_gqa, diff --git a/modules/civitai/api_civitai.py b/modules/civitai/api_civitai.py index 4a8302757..28705a641 100644 --- a/modules/civitai/api_civitai.py +++ b/modules/civitai/api_civitai.py @@ -103,10 +103,31 @@ def get_search( base_models=bm_list, nsfw=nsfw, limit=limit, cursor=cursor, username=username, favorites=favorites, token=token, ) + history_params = {k: v for k, v in { + 'types': types, + 'sort': sort, + 'period': period, + 'base_models': base_models, + 'nsfw': nsfw, + 'username': username, + 'favorites': favorites, + }.items() if v} if query: - search_history.add('query', query) + search_history.add('query', query, history_params) elif tag: - search_history.add('tag', tag) + search_history.add('tag', tag, history_params) + elif history_params: + # Filter-only browse: label the entry with the filters themselves. + parts = [ + types, + base_models, + 'favorites' if favorites else (f'by {username}' if username else ''), + period, + sort, + 'nsfw' if nsfw else '', + ] + label = ' · '.join(p for p in parts if p) + search_history.add('filter', label, history_params) return response.dict(by_alias=True) @@ -234,6 +255,95 @@ def get_download_status(): return download_manager.status() +peek_cache = None + + +def peek_cache_get(file_id: int, url: str): + """Persistent probe cache keyed by civitai file id; content per id is + immutable, so entries never expire. A url hash guards against id reuse.""" + global peek_cache # pylint: disable=global-statement + import hashlib + from modules import paths + from modules.json_helpers import readfile + if peek_cache is None: + peek_cache = readfile(paths.civitai_probe_file, silent=True, lock=True, as_type='dict') + entry = peek_cache.get(str(file_id)) + if entry and entry.get('url_hash') == hashlib.sha256(url.encode('utf-8')).hexdigest()[:16]: + return entry.get('response') + return None + + +def peek_cache_put(file_id: int, url: str, response: dict): + import hashlib + from modules import paths + from modules.json_helpers import writefile + peek_cache[str(file_id)] = { + 'url_hash': hashlib.sha256(url.encode('utf-8')).hexdigest()[:16], + 'response': response, + } + writefile(peek_cache, paths.civitai_probe_file, silent=True, atomic=True) + + +def get_peek_header(url: str, file_id: int = 0): + """Read a remote safetensors JSON header via ranged requests. Returns the + __metadata__ block plus a full model_probe analysis (architecture, + dtypes, quant scheme) without downloading the file.""" + import json + import struct + from modules import shared + # civitai.red serves the same download service and rewrites downloadUrl to + # its own host; normalize so the guard, cache hash and fetch host agree. + url = url.replace('https://civitai.red/', 'https://civitai.com/', 1) + if not url.startswith('https://civitai.com/'): + return JSONResponse(content={"error": "only civitai urls are allowed"}, status_code=400) + if file_id: + cached = peek_cache_get(file_id, url) + if cached is not None: + return cached + base_headers = {} + token = getattr(shared.opts, 'civitai_token', '') or '' + if token: + base_headers['Authorization'] = f'Bearer {token}' + + def read_range(start: int, end: int) -> bytes: + r = shared.req(url, headers={**base_headers, 'Range': f'bytes={start}-{end}'}, stream=True) + status = getattr(r, 'status_code', 500) + if status not in (200, 206): + raise RuntimeError(f'HTTP {status}') + want = end - start + 1 + # A 200 reply means the server ignored the range and sends from byte 0. + need = end + 1 if status == 200 else want + buf = b'' + try: + for chunk in r.iter_content(chunk_size=65536): + buf += chunk + if len(buf) >= need: + break + finally: + r.close() + return buf[start:start + want] if status == 200 else buf[:want] + + try: + prefix = read_range(0, 7) + if len(prefix) < 8: + return {"metadata": None, "error": "short read"} + header_len = struct.unpack(' 16 * 1024 * 1024: + return {"metadata": None, "error": f"implausible header length: {header_len}"} + header = json.loads(read_range(8, 7 + header_len).decode('utf-8')) + except Exception as e: + return {"metadata": None, "error": str(e)} + from modules import model_probe + response = { + "metadata": header.get('__metadata__'), + "tensors": len([k for k in header if k != '__metadata__']), + "probe": model_probe.analyze_header(header), + } + if file_id: + peek_cache_put(file_id, url, response) + return response + + # --------------------------------------------------------------------------- # Settings # --------------------------------------------------------------------------- @@ -585,6 +695,7 @@ def register_api(api): api.add_api_route("/sdapi/v2/civitai/download", post_download, methods=["POST"], tags=["CivitAI"]) api.add_api_route("/sdapi/v2/civitai/download/{download_id}/cancel", post_download_cancel, methods=["POST"], tags=["CivitAI"]) api.add_api_route("/sdapi/v2/civitai/download/status", get_download_status, methods=["GET"], tags=["CivitAI"]) + api.add_api_route("/sdapi/v2/civitai/peek-header", get_peek_header, methods=["GET"], tags=["CivitAI"]) api.add_api_route("/sdapi/v2/civitai/settings", get_settings, methods=["GET"], tags=["CivitAI"]) api.add_api_route("/sdapi/v2/civitai/settings", post_settings, methods=["POST"], tags=["CivitAI"]) api.add_api_route("/sdapi/v2/civitai/resolve-path", get_resolve_path, methods=["GET"], tags=["CivitAI"]) diff --git a/modules/civitai/download_civitai.py b/modules/civitai/download_civitai.py index 003467e68..833270f4c 100644 --- a/modules/civitai/download_civitai.py +++ b/modules/civitai/download_civitai.py @@ -1,4 +1,5 @@ import os +import re import uuid import hashlib import threading @@ -12,6 +13,10 @@ from modules import shared, paths from modules.logger import console +STALE_PARTIAL_DAYS = 7 +TEMP_FILE_RE = re.compile(r'^[0-9a-f]{8}\.tmp$') + + @dataclass class DownloadItem: id: str = field(default_factory=lambda: uuid.uuid4().hex[:12]) @@ -57,6 +62,27 @@ class DownloadManager: self._lock = threading.Lock() self._max_workers = max_workers self._worker_count = 0 + threading.Thread(target=self._sweep_stale_partials, daemon=True).start() + + def _sweep_stale_partials(self): + # Partials double as resume state, but mtime stops moving the moment a + # download stops, so an untouched week-old .tmp is abandoned. + try: + from modules.civitai.filemanage_civitai import iter_type_roots + cutoff = time.time() - STALE_PARTIAL_DAYS * 86400 + for root in iter_type_roots(): + for path in root.rglob('*.tmp'): + if not TEMP_FILE_RE.match(path.name): + continue + try: + stat = path.stat() + if stat.st_mtime < cutoff: + path.unlink() + log.info(f'CivitAI stale partial removed: file="{path}" size={stat.st_size/1024/1024:.0f}MB age>{STALE_PARTIAL_DAYS}d') + except OSError as e: + log.warning(f'CivitAI stale partial sweep: file="{path}" {e}') + except Exception as e: + log.warning(f'CivitAI stale partial sweep error: {e}') def enqueue(self, url: str, folder: str, filename: str, model_type: str = "", expected_hash: str = "", token: str | None = None, @@ -188,6 +214,15 @@ class DownloadManager: log.warning(f'CivitAI download invalid content-type: id={item.id} content-type="{content_type}"') return + # A 200 reply to a Range request means the server ignored the range + # and is sending the whole file; appending it to the partial would + # corrupt it. Truncate and restart from byte 0. + if starting_pos > 0 and r.status_code == 200: + log.warning(f'CivitAI download resume not supported: id={item.id} file="{item.filename}" restarting') + starting_pos = 0 + item.bytes_downloaded = 0 + os.truncate(temp_file, 0) + total_size = int(r.headers.get('content-length', 0)) item.bytes_total = starting_pos + total_size @@ -742,7 +777,6 @@ def download_civit_model(model_url: str, model_name: str = '', model_path: str = log.error('Model download: no url provided') return None if not version_id: - import re match = re.search(r'/api/download/models/(\d+)', model_url) if match: version_id = int(match.group(1)) diff --git a/modules/civitai/filemanage_civitai.py b/modules/civitai/filemanage_civitai.py index a914d0611..a7372942e 100644 --- a/modules/civitai/filemanage_civitai.py +++ b/modules/civitai/filemanage_civitai.py @@ -4,9 +4,12 @@ from pathlib import Path from modules.logger import log -# Map CivitAI model types to shared.opts directory settings and fallback subfolder names +# Map CivitAI model types to shared.opts directory settings and fallback subfolder +# names. 'Text Encoder' is a file type, not a model type: versions bundle companion +# files, and clients route those by the file's own type. TYPE_MAP = { 'Checkpoint': ('ckpt_dir', 'Stable-diffusion'), + 'Text Encoder': ('te_dir', 'Text-encoder'), 'TextualInversion': ('embeddings_dir', 'embeddings'), 'Hypernetwork': ('hypernetwork_dir', 'hypernetworks'), 'AestheticGradient': ('ckpt_dir', 'Stable-diffusion'), @@ -60,6 +63,25 @@ def get_type_folder(model_type: str, base_model: str = '') -> Path: return Path(paths.models_path) / fallback_dir +def iter_type_roots() -> set[Path]: + """Every root folder downloads can resolve into, for maintenance sweeps.""" + from modules import shared, paths + roots = set() + custom_json = getattr(shared.opts, 'civitai_save_type_folders', '') or '' + if custom_json.strip(): + try: + import json + for folder in json.loads(custom_json).values(): + p = Path(folder) + roots.add(p if p.is_absolute() else Path(paths.models_path) / folder) + except Exception: + pass + for opt_attr, fallback_dir in set(TYPE_MAP.values()) | {('unet_dir', 'UNET')}: + configured = (getattr(shared.opts, opt_attr, '') or '') if opt_attr else '' + roots.add(Path(configured) if configured else Path(paths.models_path) / fallback_dir) + return {r for r in roots if r.is_dir()} + + def resolve_save_path(model_type: str, model_name: str = "", base_model: str = "", nsfw: bool = False, creator: str = "", model_id: int = 0, version_id: int = 0, version_name: str = "") -> Path: diff --git a/modules/civitai/models_civitai.py b/modules/civitai/models_civitai.py index 4470efad3..e709e659f 100644 --- a/modules/civitai/models_civitai.py +++ b/modules/civitai/models_civitai.py @@ -25,6 +25,15 @@ class CivitFileHashes(BaseModel): blake3: str | None = Field(None, alias="BLAKE3") +class CivitFileMetadata(BaseModel): + class Config: + allow_population_by_field_name = True + format: str | None = None + size: str | None = None + fp: str | None = None + quant_type: str | None = Field(None, alias="quantType") + + class CivitFile(BaseModel): class Config: allow_population_by_field_name = True @@ -35,6 +44,10 @@ class CivitFile(BaseModel): hashes: CivitFileHashes = Field(default_factory=CivitFileHashes) download_url: str = Field("", alias="downloadUrl") primary: bool | None = None + metadata: CivitFileMetadata = Field(default_factory=CivitFileMetadata) + pickle_scan_result: str | None = Field(None, alias="pickleScanResult") + virus_scan_result: str | None = Field(None, alias="virusScanResult") + scanned_at: str | None = Field(None, alias="scannedAt") class CivitStats(BaseModel): @@ -58,6 +71,8 @@ class CivitVersion(BaseModel): base_model: str = Field("Unknown", alias="baseModel") published_at: str | None = Field(None, alias="publishedAt") availability: str = "Unknown" + early_access_ends_at: str | None = Field(None, alias="earlyAccessEndsAt") + early_access_config: dict | None = Field(None, alias="earlyAccessConfig") description: str | None = None trained_words: list[str] = Field(default_factory=list, alias="trainedWords") stats: CivitStats = Field(default_factory=CivitStats) @@ -66,6 +81,13 @@ class CivitVersion(BaseModel): nsfw_level: int = Field(0, alias="nsfwLevel") download_url: str = Field("", alias="downloadUrl") + @validator('availability', pre=True) + def coerce_null_availability(cls, v): # pylint: disable=no-self-argument + # /model-versions/{id} serializes availability as null, which failed + # str validation and turned every version lookup into a 404. Fall back + # to the default instead of rejecting the whole version. + return "Unknown" if v in (None, "") else v + class CivitCreator(BaseModel): class Config: diff --git a/modules/civitai/userdata_civitai.py b/modules/civitai/userdata_civitai.py index 64c7efae5..3d3c67f83 100644 --- a/modules/civitai/userdata_civitai.py +++ b/modules/civitai/userdata_civitai.py @@ -96,13 +96,15 @@ class SearchHistory: except Exception as e: log.error(f'CivitAI search history save error: file={path} {e}') - def add(self, search_type: str, term: str): + def add(self, search_type: str, term: str, params: dict | None = None): with self._lock: entry = { "type": search_type, "term": term, "timestamp": datetime.now().isoformat(), } + if params: + entry["params"] = params # Remove duplicate if same type+term exists self._entries = [e for e in self._entries if not (e.get('type') == search_type and e.get('term') == term)] self._entries.insert(0, entry) diff --git a/modules/infotext.py b/modules/infotext.py index f84948eed..483bbd4c3 100644 --- a/modules/infotext.py +++ b/modules/infotext.py @@ -66,12 +66,10 @@ def parse(infotext): return params params['Prompt'] = prompt if len(prompt) > 0 else None params['Negative prompt'] = negative if len(negative) > 0 else None - params['Template'] = template if len(template) > 0 else None - params['Negative template'] = negative_template if len(negative_template) > 0 else None - if params['Template'] == params['Prompt']: - params.pop('Template', None) - if params['Negative template'] == params['Negative prompt']: - params.pop('Negative template', None) + if len(template) > 0 and template != params['Prompt']: + params['Template'] = template + if len(negative_template) > 0 and negative_template != params['Negative prompt']: + params['Negative template'] = negative_template debug(f'Params: {params}') for key, val in params.copy().items(): diff --git a/modules/lora/native_adapter.py b/modules/lora/native_adapter.py index 91b6e2d2b..0ab038c73 100644 --- a/modules/lora/native_adapter.py +++ b/modules/lora/native_adapter.py @@ -48,7 +48,11 @@ from modules.lora import lora_common as l # vendor-specific naming conventions. ``lora_transformer_`` is not a vendor # format but sdnext's own internal transformer namespace; files already saved # in it (e.g. OneTrainer) pass through verbatim, see :func:`resolve_group_targets`. -KNOWN_PREFIXES_DEFAULT = ("diffusion_model.", "transformer.", "lora_unet_", "lora_transformer_") +# ``lycoris_`` is the LyCORIS-standalone save format: the wrapped diffusers +# module path with dots rendered as underscores. It is arch-independent by +# construction (the wrapped layout equals the target layout), so it lives here +# rather than in any arch's prefix list. +KNOWN_PREFIXES_DEFAULT = ("diffusion_model.", "transformer.", "lora_unet_", "lora_transformer_", "lycoris_") # Sentinel ``prefix_used`` value emitted by :func:`parse_key` when a bare path @@ -67,9 +71,9 @@ NETWORK_PREFIX_DEFAULT = "lora_transformer_" # Prefixes whose parsed ``base`` is already a network-key tail (``arch_prefix + # base.replace(".", "_")`` matches the stamped module name), so the loader binds -# them directly with no per-arch rewrite. Arch-local already-resolved prefixes -# (e.g. flux2's ``lycoris_``) stay in that arch's ``resolve_targets``. -PASSTHROUGH_PREFIXES_DEFAULT = ("transformer.", BARE_DIFFUSERS_PREFIX_USED, "lora_transformer_") +# them directly with no per-arch rewrite. ``lycoris_`` bases are already +# underscored, so the loader's ``.replace(".", "_")`` is a no-op on them. +PASSTHROUGH_PREFIXES_DEFAULT = ("transformer.", BARE_DIFFUSERS_PREFIX_USED, "lora_transformer_", "lycoris_") def _resolve_prefix(network_prefix, prefix_used): @@ -98,7 +102,12 @@ LORA_SUFFIXES = ( ".lora_down.weight", ".lora_up.weight", ".lora_mid.weight", ".lora_A.weight", ".lora_B.weight", # diff_b: bias delta some saves pair with the weight LoRA, applied as ex_bias. - ".alpha", ".dora_scale", ".bias", ".diff_b", ".scale", + # magnitude / lora_magnitude_vector: DoRA row norms (ai-toolkit / PEFT key + # names); converted onto the dora_scale path by try_load_lora. + # bias_indices/values/size: LyCORIS extraction sparse residual triplet, + # reconstructed into the dense-bias path by network.NetworkModule. + ".alpha", ".dora_scale", ".magnitude", ".lora_magnitude_vector", + ".bias", ".bias_indices", ".bias_values", ".bias_size", ".diff_b", ".scale", ) LOKR_SUFFIXES = ( ".lokr_w1", ".lokr_w2", @@ -288,6 +297,63 @@ def shapes_match(sd_module, down_w: torch.Tensor, up_w: torch.Tensor) -> bool: return down_w.shape[1] == mod_shape[1] and up_w.shape[0] == mod_shape[0] +def lokr_kron_shape(w): + """Return the ``(out, in_flat)`` shape of ``kron(w1, w2)`` from stored factors. + + Each factor is either full (``lokr_w1``/``lokr_w2``) or rank-decomposed + (``lokr_w1_a @ lokr_w1_b``); a Tucker-rebuilt w2 (conv-only) stores its + parts as ``(rank, part)`` with the kernel dims carried by ``lokr_t2``. + Kernel dims are folded into ``in_flat``, matching how the delta reshapes + onto a conv weight. + """ + w1 = w.get("lokr_w1") + r1 = w1.shape[0] if w1 is not None else w["lokr_w1_a"].shape[0] + c1 = w1.shape[1] if w1 is not None else w["lokr_w1_b"].shape[1] + w2 = w.get("lokr_w2") + t2 = w.get("lokr_t2") + if w2 is not None: + r2 = w2.shape[0] + c2_flat = w2.numel() // r2 + elif t2 is not None: + r2 = w["lokr_w2_a"].shape[1] + c2_flat = w["lokr_w2_b"].shape[1] + for d in t2.shape[2:]: + c2_flat *= d + else: + r2 = w["lokr_w2_a"].shape[0] + w2b = w["lokr_w2_b"] + c2_flat = w2b.numel() // w2b.shape[0] + return r1 * r2, c1 * c2_flat + + +def lokr_shapes_match(sd_module, kron_shape, chunk: ChunkSpec | None) -> bool: + """Kron-vs-module dim check, honoring SDNQ original shapes and chunk rows. + + The input dim is never chunked; the output dim must cover the full fused + weight for chunked targets (``total * out`` for equal chunks, ``end <= + kron_out`` with an exact row-range for slices). + """ + if not hasattr(sd_module, "weight"): + return False + if hasattr(sd_module, "sdnq_dequantizer"): + mod_shape = sd_module.sdnq_dequantizer.original_shape + else: + mod_shape = sd_module.weight.shape + if len(mod_shape) < 2: + return False + mod_in_flat = 1 + for d in mod_shape[1:]: + mod_in_flat *= d + kron_out, kron_in_flat = kron_shape + if kron_in_flat != mod_in_flat: + return False + if chunk is None: + return kron_out == mod_shape[0] + if chunk.is_equal_chunks: + return kron_out == mod_shape[0] * chunk.total + return (chunk.end - chunk.start) == mod_shape[0] and kron_out >= chunk.end + + # === Parsing primitives === @@ -403,27 +469,75 @@ def resolve_group_targets(resolve_targets, prefix_used, base): # slices and Tucker-decomposed LoHAs on fused targets are skipped with a # warning (no slice variant exists, and Tucker keys cannot arise on Linear # layers per LyCORIS upstream — see network_hada.NetworkModuleHadaChunk). +# +# DoRA on fused targets (LoRA/LoKR/LoHA): per-output dora_scale rows are +# sliced with the chunk via slice_dora_scale (exact, row norms are +# independent); per-input dora_scale couples the chunks through shared +# column norms and the group is skipped with a warning. +# +# Bias companions on fused targets: per-output diff_b deltas slice with the +# chunk (LoRA only; no other family's save format pairs them). The legacy +# weight-shaped "bias" key has no defined partition and skips the group. # - OFT/BOFT: no chunk variant exists; fused targets are skipped with a # warning. Discrimination is by ``oft_blocks.ndim`` (3-D OFT, 4-D BOFT), # mirroring upstream LyCORIS ``algo_check``. -def _slice_lora_chunk(w, chunk: ChunkSpec): - """Return a shallow copy of ``w`` with ``lora_up.weight`` sliced per ``chunk``. +def slice_chunk_rows(t, chunk: ChunkSpec): + """Slice dim 0 of ``t`` per ``chunk``. Equal-chunks form uses ``torch.chunk`` (faster for the symmetric case); row-range form uses tensor slicing for arbitrary partitions. """ - up = w["lora_up.weight"] if chunk.is_equal_chunks: - sliced = torch.chunk(up, chunk.total, dim=0)[chunk.idx].contiguous() - else: - sliced = up[chunk.start:chunk.end].contiguous() + return torch.chunk(t, chunk.total, dim=0)[chunk.idx].contiguous() + return t[chunk.start:chunk.end].contiguous() + + +def _slice_lora_chunk(w, chunk: ChunkSpec): + """Return a shallow copy of ``w`` with ``lora_up.weight`` sliced per ``chunk``.""" out = dict(w) - out["lora_up.weight"] = sliced + out["lora_up.weight"] = slice_chunk_rows(w["lora_up.weight"], chunk) return out +def slice_dora_scale(w, chunk: ChunkSpec, fused_out): + """Slice a per-output ``dora_scale`` to the chunk rows; ``None`` if unsliceable. + + LyCORIS ``wd_on_out=True`` (the LoKr/LoHA default) stores per-output + magnitudes of shape ``(out, 1)`` (1-D ``(out,)`` also seen); the rows + partition exactly with the fused weight, so the chunk slice preserves the + DoRA math (row norms are independent across rows). ``wd_on_out=False`` + stores per-input magnitudes whose column norms span every fused row, + coupling the chunks; no exact per-chunk equivalent exists and the caller + must skip the group. + """ + ds = w.get("dora_scale") + if ds is None: + return w + if ds.ndim >= 1 and ds.shape[0] == fused_out: + out = dict(w) + out["dora_scale"] = slice_chunk_rows(ds, chunk) + return out + return None + + +def slice_bias_delta(w, chunk: ChunkSpec, fused_out): + """Slice a per-output ``diff_b`` bias delta to the chunk rows; ``None`` if unsliceable. + + ``diff_b`` stores one bias value per output feature, so it partitions with + the fused rows exactly like the up-weight. + """ + db = w.get("diff_b") + if db is None: + return w + if db.ndim >= 1 and db.shape[0] == fused_out: + out = dict(w) + out["diff_b"] = slice_chunk_rows(db, chunk) + return out + return None + + def try_load_lora(name, network_on_disk, lora_scale, *, resolve_targets, prefixes=KNOWN_PREFIXES_DEFAULT, bare_prefixes=(), bare_diffusers_prefixes=(), @@ -450,9 +564,20 @@ def try_load_lora(name, network_on_disk, lora_scale, *, unmapped = 0 mismatch = 0 + skipped = 0 for (prefix, base), w in groups.items(): if "lora_down.weight" not in w or "lora_up.weight" not in w: continue + # DoRA magnitude vectors: ai-toolkit saves `magnitude`, PEFT/diffusers + # `lora_magnitude_vector`. Both are 1-D per-output row norms with + # dora_scale semantics; reshape to (out, 1) so the apply-time + # orientation detection cannot misread square layers as per-input. + for mag_key in ("magnitude", "lora_magnitude_vector"): + mag = w.get(mag_key) + if mag is not None and "dora_scale" not in w: + w = dict(w) + w.pop(mag_key) + w["dora_scale"] = mag.reshape(-1, 1) if mag.ndim == 1 else mag arch_prefix = _resolve_prefix(network_prefix, prefix) for diffusers_path, chunk in resolve_group_targets(resolve_targets, prefix, base): network_key = arch_prefix + diffusers_path.replace(".", "_") @@ -461,7 +586,26 @@ def try_load_lora(name, network_on_disk, lora_scale, *, unmapped += 1 continue - target_w = _slice_lora_chunk(w, chunk) if chunk is not None else w + target_w = w + if chunk is not None: + if "bias" in w or "bias_indices" in w: + # Weight-shaped bias residuals (dense or LyCORIS sparse + # triplet) are not partitioned onto fused targets. + log.warning(f'Network load: type=LoRA name="{name}" arch={arch_name} key={network_key} weight-shaped bias on fused target skipped (unsupported)') + skipped += 1 + continue + fused_out = w["lora_up.weight"].shape[0] + target_w = _slice_lora_chunk(w, chunk) + target_w = slice_dora_scale(target_w, chunk, fused_out) + if target_w is None: + log.warning(f'Network load: type=LoRA name="{name}" arch={arch_name} key={network_key} per-input DoRA on fused target skipped (unsupported)') + skipped += 1 + continue + target_w = slice_bias_delta(target_w, chunk, fused_out) + if target_w is None: + log.warning(f'Network load: type=LoRA name="{name}" arch={arch_name} key={network_key} non-per-output diff_b on fused target skipped (unsupported)') + skipped += 1 + continue if not shapes_match(sd_module, target_w["lora_down.weight"], target_w["lora_up.weight"]): log.warning( @@ -476,14 +620,14 @@ def try_load_lora(name, network_on_disk, lora_scale, *, nw = network.NetworkWeights(network_key=network_key, sd_key=network_key, w=target_w, sd_module=sd_module) net.modules[network_key] = network_lora.NetworkModuleLora(net, nw) - return finalize_network(net, name, "LoRA", lora_scale, t0, unmapped=unmapped, mismatch=mismatch) + return finalize_network(net, name, "LoRA", lora_scale, t0, unmapped=unmapped, mismatch=mismatch, skipped=skipped) def try_load_lokr(name, network_on_disk, lora_scale, *, resolve_targets, prefixes=KNOWN_PREFIXES_DEFAULT, bare_prefixes=(), bare_diffusers_prefixes=(), network_prefix=NETWORK_PREFIX_DEFAULT, - arch_name="generic"): # pylint: disable=unused-argument + arch_name="generic"): """Generic LoKR loader. Stores only the compact LoKR factors and dispatches to @@ -508,19 +652,48 @@ def try_load_lokr(name, network_on_disk, lora_scale, *, ) unmapped = 0 + mismatch = 0 + skipped = 0 for (prefix, base), w in groups.items(): has_1 = "lokr_w1" in w or ("lokr_w1_a" in w and "lokr_w1_b" in w) has_2 = "lokr_w2" in w or ("lokr_w2_a" in w and "lokr_w2_b" in w) if not (has_1 and has_2): continue arch_prefix = _resolve_prefix(network_prefix, prefix) + kron_shape = lokr_kron_shape(w) for diffusers_path, chunk in resolve_group_targets(resolve_targets, prefix, base): network_key = arch_prefix + diffusers_path.replace(".", "_") sd_module = mapping.get(network_key) if sd_module is None: unmapped += 1 continue - nw = network.NetworkWeights(network_key=network_key, sd_key=network_key, w=w, sd_module=sd_module) + if not lokr_shapes_match(sd_module, kron_shape, chunk): + log.warning( + f'Network load: type=LoKR name="{name}" arch={arch_name} key={network_key}' + f' kron={kron_shape[0]}x{kron_shape[1]}' + f' module={getattr(sd_module, "weight", None).shape if hasattr(sd_module, "weight") else "?"}' + f' shape mismatch' + ) + mismatch += 1 + continue + target_w = w + if chunk is not None: + if "bias" in w: + log.warning(f'Network load: type=LoKR name="{name}" arch={arch_name} key={network_key} weight-shaped bias on fused target skipped (unsupported)') + skipped += 1 + continue + # Kron rows = w1 rows * w2 rows; the tucker w2_a orientation + # differs but tucker is conv-only and chunks are Linear-only. + w1 = w.get("lokr_w1") + w2 = w.get("lokr_w2") + w1_rows = w1.shape[0] if w1 is not None else w["lokr_w1_a"].shape[0] + w2_rows = w2.shape[0] if w2 is not None else w["lokr_w2_a"].shape[0] + target_w = slice_dora_scale(w, chunk, fused_out=w1_rows * w2_rows) + if target_w is None: + log.warning(f'Network load: type=LoKR name="{name}" arch={arch_name} key={network_key} per-input DoRA on fused target skipped (unsupported)') + skipped += 1 + continue + nw = network.NetworkWeights(network_key=network_key, sd_key=network_key, w=target_w, sd_module=sd_module) if chunk is None: net.modules[network_key] = network_lokr.NetworkModuleLokr(net, nw) elif chunk.is_equal_chunks: @@ -528,7 +701,7 @@ def try_load_lokr(name, network_on_disk, lora_scale, *, else: net.modules[network_key] = network_lokr.NetworkModuleLokrSliceChunk(net, nw, chunk.start, chunk.end) - return finalize_network(net, name, "LoKR", lora_scale, t0, unmapped=unmapped) + return finalize_network(net, name, "LoKR", lora_scale, t0, unmapped=unmapped, mismatch=mismatch, skipped=skipped) def try_load_loha(name, network_on_disk, lora_scale, *, @@ -577,7 +750,18 @@ def try_load_loha(name, network_on_disk, lora_scale, *, if sd_module is None: unmapped += 1 continue - nw = network.NetworkWeights(network_key=network_key, sd_key=network_key, w=w, sd_module=sd_module) + target_w = w + if chunk is not None: + if "bias" in w: + log.warning(f'Network load: type=LoHA name="{name}" arch={arch_name} key={network_key} weight-shaped bias on fused target skipped (unsupported)') + skipped += 1 + continue + target_w = slice_dora_scale(w, chunk, fused_out=w["hada_w1_a"].shape[0]) + if target_w is None: + log.warning(f'Network load: type=LoHA name="{name}" arch={arch_name} key={network_key} per-input DoRA on fused target skipped (unsupported)') + skipped += 1 + continue + nw = network.NetworkWeights(network_key=network_key, sd_key=network_key, w=target_w, sd_module=sd_module) if chunk is None: net.modules[network_key] = network_hada.NetworkModuleHada(net, nw) elif chunk.is_equal_chunks: @@ -855,6 +1039,12 @@ def try_load_full(name, network_on_disk, lora_scale, *, if sd_module is None: unmapped += 1 continue + # Loader-local stamping, same as try_load_norm: a full-weight extraction carries the + # norm weights too, and assign_network_names_to_compvis_modules puts norms in the + # mapping but never stamps network_layer_name on them, which is what the apply pass + # keys off. Without this they bind and then silently never apply. + if not getattr(sd_module, "network_layer_name", None): + sd_module.network_layer_name = network_key nw = network.NetworkWeights(network_key=network_key, sd_key=network_key, w=w, sd_module=sd_module) net.modules[network_key] = network_full.NetworkModuleFull(net, nw) diff --git a/modules/lora/network.py b/modules/lora/network.py index 99516b6e4..e05f6abe9 100644 --- a/modules/lora/network.py +++ b/modules/lora/network.py @@ -1,6 +1,7 @@ import os import enum from collections import namedtuple +import torch from modules import hashes, shared, sd_checkpoint @@ -174,6 +175,16 @@ class NetworkModule: self.shape = self.sd_module.weight.shape self.dim = None self.bias = weights.w.get("bias") + if self.bias is None and "bias_indices" in weights.w: + # LyCORIS extraction with use_bias: the sparse weight-shaped + # remainder of the SVD extraction ("bias" is historical naming), + # stored COO with int16 indices. Kept sparse; finalize_updown's + # dense += sparse materializes it per module at apply time. + self.bias = torch.sparse_coo_tensor( + weights.w["bias_indices"].to(torch.long), + weights.w["bias_values"], + tuple(weights.w["bias_size"]), + ) self.alpha = weights.w["alpha"].item() if "alpha" in weights.w else None self.scale = weights.w["scale"].item() if "scale" in weights.w else None self.dora_scale = weights.w.get("dora_scale", None) @@ -268,7 +279,13 @@ class NetworkModule: if ex_bias is not None: ex_bias = ex_bias * self.multiplier() if self.dora_scale is not None: - updown = self.apply_weight_decompose(updown, orig_weight) + # LyCORIS/ComfyUI convention: alpha/rank is baked into the diff + # before the decompose norm. The multiplier then lerps the full + # merged delta (ComfyUI semantics: 0 disables, 1 equals the + # trainer's output; LyCORIS weight-mode ratio interpolation is + # not used since it leaves the diff applied at multiplier 0). + updown = self.apply_weight_decompose(updown * self.calc_scale(), orig_weight) + return updown * self.multiplier(), ex_bias return updown * self.calc_scale() * self.multiplier(), ex_bias def calc_updown(self, target): diff --git a/modules/ltx/ltx_ui.py b/modules/ltx/ltx_ui.py index 4990a5796..d15c4aa78 100644 --- a/modules/ltx/ltx_ui.py +++ b/modules/ltx/ltx_ui.py @@ -4,7 +4,7 @@ from modules import ui_sections, ui_symbols from modules.ui_components import ToolButton from modules.logger import log from modules.video_models.models_def import models -from modules.ltx import ltx_process, ltx_capabilities +from modules.ltx import ltx_process, ltx_capabilities, ltx_util debug = log.trace if os.environ.get('SD_VIDEO_DEBUG', None) is not None else lambda *args, **kwargs: None @@ -63,6 +63,7 @@ def create_ui(prompt, negative, styles, overrides, mp4_fps, mp4_interpolate, mp4 with gr.Row(): ltx_models = [m.name for m in models['LTX Video']] if 'LTX Video' in models else ['None'] model = gr.Dropdown(label='LTX model', choices=ltx_models, value=ltx_models[0], elem_id="ltx_model") + btn_load = ToolButton(ui_symbols.loading, elem_id="video_model_load_ltx") with gr.Accordion(open=False, label='Size', elem_id='ltx_size_accordion'): width, height = ui_sections.create_resolution_inputs('ltx', default_width=832, default_height=480) with gr.Row(): @@ -119,6 +120,12 @@ def create_ui(prompt, negative, styles, overrides, mp4_fps, mp4_interpolate, mp4 with gr.Row(): text = gr.HTML('', elem_id='ltx_generation_info', show_label=False) + + def load_model(model_name: str): + ltx_util.load_model('LTX Video', model_name) + + btn_load.click(fn=load_model, inputs=[model], outputs=[]) + model.change( fn=_model_change, inputs=[model], diff --git a/modules/ltx/ltx_util.py b/modules/ltx/ltx_util.py index 8aa0b12ec..032bc04b8 100644 --- a/modules/ltx/ltx_util.py +++ b/modules/ltx/ltx_util.py @@ -28,7 +28,7 @@ def load_model(engine: str, model: str): selected: models_def.Model = [m for m in models_def.models[engine] if m.name == model][0] # video_load owns the cache; pipe-class mismatch inside it invalidates the name-based hit # when Unload Models (or any external swap) silently replaced shared.sd_model. - log.info(f'Video load: engine="{engine}" selected="{model}" {selected}') + log.info(f'Load video: engine="{engine}" selected="{model}" {selected}') video_load.load_model(selected) t1 = time.time() shared.sd_model = sd_models.apply_balanced_offload(shared.sd_model) @@ -41,7 +41,7 @@ def load_upsample(upsample_pipe, upsample_repo_id): if upsample_pipe is None: t0 = time.time() from diffusers.pipelines.ltx.pipeline_ltx_latent_upsample import LTXLatentUpsamplePipeline - log.info(f'Video load: cls={LTXLatentUpsamplePipeline.__name__} repo="{upsample_repo_id}"') + log.info(f'Load video: cls={LTXLatentUpsamplePipeline.__name__} repo="{upsample_repo_id}"') upsample_pipe = LTXLatentUpsamplePipeline.from_pretrained( upsample_repo_id, vae=shared.sd_model.vae, @@ -61,7 +61,7 @@ def load_upsample_2x(upsample_pipe, upsample_repo_id): from diffusers.pipelines.ltx2.pipeline_ltx2_latent_upsample import LTX2LatentUpsamplePipeline from diffusers.pipelines.ltx2.latent_upsampler import LTX2LatentUpsamplerModel from modules import sd_checkpoint - log.info(f'Video load: cls={LTX2LatentUpsamplePipeline.__name__} repo="{upsample_repo_id}"') + log.info(f'Load video: cls={LTX2LatentUpsamplePipeline.__name__} repo="{upsample_repo_id}"') latent_upsampler = LTX2LatentUpsamplerModel.from_pretrained( upsample_repo_id, subfolder='latent_upsampler', diff --git a/modules/model_probe.py b/modules/model_probe.py new file mode 100644 index 000000000..7972c7fdd --- /dev/null +++ b/modules/model_probe.py @@ -0,0 +1,429 @@ +"""Header-only model analysis: architecture fingerprinting, precision/quant +detection, and embedded metadata extraction from safetensors/gguf files +without reading tensor data. Consumed by the civitai remote peek and the +local model audit; analyze_header is pure so both paths share one analyzer. +""" +import os +import re +import json +from collections import Counter +from dataclasses import dataclass + + +SCHEMA_VERSION = 5 +MAX_HEADER_BYTES = 16 * 1024 * 1024 +STRIP_PREFIXES = ('model.diffusion_model.', 'diffusion_model.', 'net.') +# companion families bundled alongside the diffusion core in full checkpoints +COMPANION_PREFIXES = ('text_encoders.', 'cond_stage_model.', 'conditioner.', 'first_stage_model.', 'vae.', 'vocoder.', 'audio_vae.') +LORA_SUFFIXES = ('.lora_down.weight', '.lora_up.weight', '.lora_A.weight', '.lora_B.weight', '.hada_w1_a', '.lokr_w1', '.lokr_w2', '.dora_scale', '.diff', '.diff_b') + + +@dataclass(frozen=True) +class ArchFingerprint: + family: str + display: str + required: tuple # regex fragments, all must match at least one inner key + forbidden: tuple = () + weight: int = 1 + + +# Markers verified against real headers (local library + civitai ranged peeks). +# Families not listed report 'unknown' rather than guessing. +FINGERPRINTS = ( + ArchFingerprint('sdxl', 'Stable Diffusion XL', (r'^input_blocks\.', r'^middle_block\.', r'^label_emb\.')), + ArchFingerprint('sd', 'Stable Diffusion 1.x/2.x', (r'^input_blocks\.', r'^middle_block\.'), forbidden=(r'^label_emb\.',)), + ArchFingerprint('sd3', 'Stable Diffusion 3', (r'^joint_blocks\.', r'^context_embedder\.')), + ArchFingerprint('f1', 'FLUX.1', (r'^double_blocks\.\d+\.img_attn', r'^vector_in\.'), forbidden=(r'^distilled_guidance_layer\.', r'stream_modulation')), + ArchFingerprint('chroma', 'Chroma', (r'^double_blocks\.\d+\.img_attn', r'^distilled_guidance_layer\.')), + ArchFingerprint('f2', 'FLUX.2', (r'^double_blocks\.\d+\.img_attn', r'stream_modulation'), forbidden=(r'^vector_in\.',)), + ArchFingerprint('qwen', 'Qwen Image', (r'^transformer_blocks\.\d+\.img_mlp', r'^time_text_embed\.'), forbidden=(r'audio_attn',)), + ArchFingerprint('krea2', 'Krea 2', (r'^blocks\.\d+\.attn', r'^txtfusion\.')), + ArchFingerprint('wanai-animate', 'Wan 2.2 Animate', (r'^blocks\.\d+\.cross_attn', r'^patch_embedding\.', r'^face_adapter\.|^motion_encoder\.|^pose_patch_embedding\.')), + ArchFingerprint('wanai', 'Wan DiT', (r'^blocks\.\d+\.cross_attn', r'^blocks\.\d+\.self_attn', r'^patch_embedding\.', r'^time_projection\.'), forbidden=(r'^face_adapter\.', r'^motion_encoder\.', r'^pose_patch_embedding\.', r'^llm_adapter\.')), + ArchFingerprint('anima', 'Anima', (r'^blocks\.\d+\.cross_attn', r'^llm_adapter\.')), + ArchFingerprint('ernieimage', 'Ernie Image', (r'^layers\.\d+\.self_attention', r'^adaLN_sa_ln|^final_norm\.')), + ArchFingerprint('zimage', 'Z-Image', (r'^layers\.\d+\.attention', r'^noise_refiner\.', r'^cap_embedder\.')), + ArchFingerprint('ltxvideo', 'LTX Video', (r'^transformer_blocks\.\d+\.attn1', r'^adaln_single\.|^vocoder\.')), + ArchFingerprint('ideogram4', 'Ideogram 4', (r'^layers\.\d+\.attention\.(qkv|o)\.', r'^adaln_proj\.|^t_embedding\.')), +) + +# name/text to family hints, ordered specific-first; matched against lowercased +# text with spaces removed. Used for lora trainer metadata and for names that +# imply a base (folder names, base tags). +FAMILY_NAME_HINTS = ( + ('stable-diffusion-xl', 'sdxl'), ('sdxl', 'sdxl'), ('sd_xl', 'sdxl'), + ('animagine', 'sdxl'), ('pony', 'sdxl'), ('illustrious', 'sdxl'), ('noobai', 'sdxl'), + ('stable-diffusion-3', 'sd3'), ('sd3', 'sd3'), + ('stable-diffusion-v1', 'sd'), ('sd-v1', 'sd'), ('sd_v1', 'sd'), ('sd15', 'sd'), ('sd1.5', 'sd'), ('sd2', 'sd'), + ('flux.2', 'f2'), ('flux2', 'f2'), ('klein', 'f2'), ('chroma', 'chroma'), ('flux', 'f1'), + ('krea', 'krea2'), ('qwen', 'qwen'), ('wan', 'wanai'), ('anima', 'anima'), + ('ideogram', 'ideogram4'), ('z-image', 'zimage'), ('zimage', 'zimage'), + ('ernie', 'ernieimage'), ('ltx', 'ltxvideo'), +) + + +def family_from_text(text: str) -> str | None: + compact = (text or '').lower().replace(' ', '') + for hint, family in FAMILY_NAME_HINTS: + if hint in compact: + return family + return None +LORA_KEY_HINTS = ( + ('txtfusion', 'krea2'), + ('distilled_guidance', 'chroma'), + ('stream_modulation', 'f2'), + ('double_blocks', 'f1'), + ('joint_blocks', 'sd3'), + ('llm_adapter', 'anima'), + ('cross_attn', 'wanai'), + ('img_mlp', 'qwen'), + ('noise_refiner', 'zimage'), + ('context_refiner', 'zimage'), + # diffusers flux layout; f1 vs f2 not separable from lora keys + ('single_transformer_blocks', 'f1'), + ('transformer_blocks', 'qwen'), +) +# checked in order; trainers sometimes write a bogus modelspec.architecture +# while ss_base_model_version names the real base +LORA_META_KEYS = ('ss_base_model_version', 'modelspec.architecture', 'ss_sd_model_name') +FAMILY_DISPLAY = {fp.family: fp.display for fp in FINGERPRINTS} + +# expert-role vocabulary for dual-transformer archs, matched against +# __metadata__ values; wan uses phrases because a bare 'high' appears in +# unrelated metadata (e.g. 'high quality') +ROLE_WORDS = { + 'wanai': (('high-noise', ('high noise',)), ('low-noise', ('low noise',))), + 'ideogram4': (('uncond', ('uncond', 'unconditional')),), +} + + +def strip_key(key: str) -> str: + for prefix in STRIP_PREFIXES: + if key.startswith(prefix): + return key[len(prefix):] + return key + + +def split_words(text: str) -> str: + text = re.sub(r'([a-z0-9])([A-Z])', r'\1 \2', text or '') + return re.sub(r'[^a-zA-Z0-9]+', ' ', text).lower() + + +def detect_kind(inner_keys: list) -> str: + """Container-level classification before arch matching.""" + if any(k.endswith(LORA_SUFFIXES) or '.lora_down.' in k or '.lora_up.' in k or '.lora.down.' in k or '.lora.up.' in k or '.lora_A.' in k or '.lora_B.' in k for k in inner_keys): + return 'lora' + top = Counter(k.split('.')[0] for k in inner_keys) + total = sum(top.values()) + vae_keys = top.get('encoder', 0) + top.get('decoder', 0) + top.get('quant_conv', 0) + top.get('post_quant_conv', 0) + if total > 0 and top.get('decoder', 0) > 0 and vae_keys > total * 0.9: + return 'vae' + diffusion_core = any(k.startswith(('input_blocks', 'double_blocks', 'blocks.', 'layers.', 'transformer_blocks', 'joint_blocks')) for k in inner_keys) + llm_markers = any(('.mlp.gate_proj' in k or 'embed_tokens' in k or '.DenseReluDense.' in k) for k in inner_keys) or top.get('shared', 0) > 0 + if not diffusion_core and llm_markers: + return 'text-encoder' + return 'model' + + +def lora_context_dim(shapes: dict | None) -> int | None: + """Cross-attention context width from a lora down/A tensor: 768 for sd1.x, + 1024 for sd2.x, 2048 for sdxl. Arbitrates when trainer metadata lies.""" + for k, shape in (shapes or {}).items(): + if 'attn2' in k and 'to_k' in k and ('lora_down' in k or '.lora.down.' in k or 'lora_A' in k): + if isinstance(shape, (list, tuple)) and len(shape) == 2: + return int(shape[1]) + return None + + +def match_lora_base(core_keys: list, metadata: dict | None, shapes: dict | None = None): + """Loras train a module subset, so full fingerprints cannot apply. Trainer + metadata names the base; keyless PEFT loras resolve via distinctive + substrings. Returns (family, confidence, marker) or None.""" + def unet_split(family, confidence, marker): + # sd-vs-sdxl from metadata or key heuristics is unreliable; shapes win + dim = lora_context_dim(shapes) + if dim is not None: + return ('sdxl' if dim >= 2048 else 'sd'), 0.8, f'shape:context-dim={dim}' + return family, confidence, marker + + for key in LORA_META_KEYS: + family = family_from_text(str((metadata or {}).get(key, ''))) + if family is not None: + if family in ('sd', 'sdxl'): + return unet_split(family, 0.9, f'metadata:{key}') + return family, 0.9, f'metadata:{key}' + joined = '\n'.join(core_keys) + for hint, family in LORA_KEY_HINTS: + if hint in joined: + return family, 0.5, f'key:{hint}' + # bare blocks.N.attn without self/cross variants is the krea2 DiT layout + if re.search(r'blocks\.\d+\.attn\.', joined) and 'self_attn' not in joined: + return 'krea2', 0.5, 'key:blocks.attn' + if 'input_blocks' in joined or 'down_blocks' in joined: + return unet_split('sdxl' if 'te2' in joined else 'sd', 0.5, 'key:unet-blocks') + return None + + +def match_arch(keys: list, metadata: dict | None, shapes: dict | None = None) -> dict: + inner = [strip_key(k) for k in keys] + core = [k for k in inner if not k.startswith(COMPANION_PREFIXES)] + prefixes = {k[: len(k) - len(s)] for k, s in ((k, strip_key(k)) for k in keys) if k != s} + kind = detect_kind(core) + matched_family = None + matched_markers = [] + candidates = [] + confidence = 0.0 + if kind == 'model': + for fp in FINGERPRINTS: + hits = [pat for pat in fp.required if any(re.search(pat, k) for k in core)] + if len(hits) < len(fp.required): + continue + if any(any(re.search(pat, k) for k in core) for pat in fp.forbidden): + continue + candidates.append(fp) + if matched_family is None: + matched_family = fp.family + matched_markers = hits + confidence = 1.0 if matched_family and len(candidates) == 1 else (0.7 if matched_family else 0.0) + elif kind == 'lora': + resolved = match_lora_base(core, metadata, shapes) + if resolved is not None: + matched_family, confidence, marker = resolved + matched_markers = [marker] + variant = None + if matched_family is not None and metadata: + meta_text = split_words(' '.join(str(v) for v in metadata.values() if isinstance(v, str))) + for suffix, words in ROLE_WORDS.get(matched_family, ()): + if any(re.search(rf'\b{w}\b', meta_text) for w in words): + variant = suffix + break + return { + 'kind': kind, + 'family': matched_family or 'unknown', + 'display': FAMILY_DISPLAY.get(matched_family, 'Unknown') if matched_family else 'Unknown', + 'confidence': confidence, + 'variant': variant, + 'detected_prefix': sorted(prefixes)[0] if prefixes else '', + 'matched_markers': matched_markers, + 'candidates': [{'family': fp.family, 'display': fp.display} for fp in candidates], + } + + +# storage dtype of a marked layer's weight identifies its comfy_quant format +COMFY_QUANT_DTYPE_FORMATS = {'I8': 'int8_tensorwise', 'F8_E4M3': 'float8_e4m3fn', 'U8': 'nvfp4'} + + +def detect_quant(keys: list, dtypes: Counter, container: str, metadata: dict | None = None, key_dtypes: dict | None = None) -> dict: + if container == 'gguf': + quantized = {d: n for d, n in dtypes.items() if d not in ('F32', 'F16', 'BF16')} + dominant = max(quantized, key=quantized.get) if quantized else None + return {'scheme': 'gguf' if dominant else None, 'format': dominant, 'marked_layers': None, 'source': 'gguf-qtype'} + quant_metadata = (metadata or {}).get('_quantization_metadata') + if quant_metadata: + try: + layers = (json.loads(quant_metadata) if isinstance(quant_metadata, str) else quant_metadata).get('layers') or {} + except Exception: + layers = {} + formats = Counter(entry.get('format') for entry in layers.values() if isinstance(entry, dict) and entry.get('format')) + if formats: + return {'scheme': 'comfy_quant', 'format': formats.most_common(1)[0][0], 'marked_layers': len(layers), 'source': 'header'} + comfy = [k for k in keys if k.endswith('.comfy_quant')] + if comfy: + weight_dtypes = Counter() + for marker in comfy: + dtype = (key_dtypes or {}).get(f"{marker[: -len('.comfy_quant')]}.weight") + if dtype: + weight_dtypes[dtype] += 1 + dominant = weight_dtypes.most_common(1)[0][0] if weight_dtypes else None + return {'scheme': 'comfy_quant', 'format': COMFY_QUANT_DTYPE_FORMATS.get(dominant), 'marked_layers': len(comfy), 'source': 'weight-dtype'} + has_fp8 = dtypes.get('F8_E4M3', 0) + dtypes.get('F8_E5M2', 0) > 0 + has_scales = any(k.endswith(('scaled_fp8', '.scale_weight', '.scale_input', '.weight_scale')) for k in keys) + if has_fp8 and has_scales: + return {'scheme': 'scaled_fp8', 'format': 'float8_e4m3fn' if dtypes.get('F8_E4M3') else 'float8_e5m2', 'marked_layers': None, 'source': 'marker'} + return {'scheme': None, 'format': None, 'marked_layers': None, 'source': None} + + +def analyze_header(header: dict, container: str = 'safetensors', arch_metadata: dict | None = None) -> dict: + metadata = header.get('__metadata__') or {} + if arch_metadata: + metadata = {**metadata, **arch_metadata} + entries = {k: v for k, v in header.items() if k != '__metadata__' and isinstance(v, dict)} + keys = list(entries) + dtypes = Counter(v.get('dtype') for v in entries.values() if v.get('dtype')) + params = 0 + # dominant dtype is element-weighted over core tensors only: bundled + # companions and scale scalars must not outvote the diffusion weights + core_elements = Counter() + for k, v in entries.items(): + shape = v.get('shape') + if not isinstance(shape, (list, tuple)) or k.endswith('.comfy_quant'): + continue + n = 1 + for dim in shape: + n *= int(dim) + params += n + if not strip_key(k).startswith(COMPANION_PREFIXES) and v.get('dtype'): + core_elements[v['dtype']] += n + inner_keys = [strip_key(k) for k in keys] + shapes = {k: v.get('shape') for k, v in entries.items()} + arch = match_arch(keys, metadata, shapes) + key_dtypes = {strip_key(k): v.get('dtype') for k, v in entries.items()} + quant = detect_quant(inner_keys, dtypes, container, metadata=metadata, key_dtypes=key_dtypes) + flags = [] + if not metadata: + flags.append('no_metadata') + if any(k.startswith(COMPANION_PREFIXES) for k in inner_keys): + flags.append('companion_bundled') + if quant['scheme'] == 'comfy_quant': + flags.append('comfy_marker') + if arch['family'] == 'wanai' and arch['variant'] is None: + flags.append('role_ambiguous') + if arch['kind'] == 'lora' and 0 < arch['confidence'] < 0.9: + flags.append('lora_base_inferred') + return { + 'schema': SCHEMA_VERSION, + 'ok': True, + 'error': None, + 'container': container, + 'tensors': len(keys), + 'params': params, + 'dtypes': dict(dtypes), + 'dominant_dtype': core_elements.most_common(1)[0][0] if core_elements else (dtypes.most_common(1)[0][0] if dtypes else None), + 'arch': arch, + 'quant': quant, + 'metadata': metadata, + 'metadata_present': bool(metadata), + 'flags': flags, + } + + +def error_result(container: str, error: str, flag: str = 'unreadable') -> dict: + return { + 'schema': SCHEMA_VERSION, 'ok': False, 'error': error, 'container': container, + 'tensors': 0, 'params': 0, 'dtypes': {}, 'dominant_dtype': None, + 'arch': {'kind': 'unknown', 'family': 'unknown', 'display': 'Unknown', 'confidence': 0.0, 'variant': None, 'detected_prefix': '', 'matched_markers': [], 'candidates': []}, + 'quant': {'scheme': None, 'format': None, 'marked_layers': None, 'source': None}, + 'metadata': {}, 'metadata_present': False, 'flags': [flag], + } + + +def read_safetensors_header(path: str) -> dict: + """Raw header read: 8-byte length prefix + JSON. Does not touch the global + sd_metadata cache and keeps ss_tag_frequency at full fidelity.""" + with open(path, 'rb') as f: + header_len = int.from_bytes(f.read(8), 'little') + if header_len <= 0 or header_len > MAX_HEADER_BYTES: + raise ValueError(f'implausible header length: {header_len}') + return json.loads(f.read(header_len).decode('utf-8')) + + +def comfy_marker_format(path: str) -> str | None: + """Exact comfy_quant format string from the first marker tensor's bytes; + only possible for local files, remote peeks stay dtype-inferred.""" + try: + with open(path, 'rb') as f: + header_len = int.from_bytes(f.read(8), 'little') + if header_len <= 0 or header_len > MAX_HEADER_BYTES: + return None + header = json.loads(f.read(header_len).decode('utf-8')) + for k, v in header.items(): + if k == '__metadata__' or not k.endswith('.comfy_quant') or not isinstance(v, dict): + continue + start, end = v.get('data_offsets', (0, 0)) + if end <= start or end - start > 4096: + return None + f.seek(8 + header_len + start) + fmt = json.loads(f.read(end - start).decode('utf-8')).get('format') + return str(fmt) if fmt else None + except Exception: + return None + return None + + +# quant format / dtype to the precision token used in filenames; fp8 stays +# variant-specific because e4m3fn and e5m2 differ in kernel support +QUANT_PRECISION_TOKENS = {'int8_tensorwise': 'int8', 'float8_e4m3fn': 'fp8_e4m3fn', 'float8_e5m2': 'fp8_e5m2', 'nvfp4': 'nvfp4', 'mxfp8': 'mxfp8'} +DTYPE_PRECISION_TOKENS = {'F32': 'fp32', 'F16': 'fp16', 'BF16': 'bf16', 'F8_E4M3': 'fp8_e4m3fn', 'F8_E5M2': 'fp8_e5m2'} + + +def precision_token(probe: dict) -> str | None: + """Filename token for a probe's true precision; None when the container + encodes it already (gguf) or nothing is known.""" + quant = probe.get('quant') or {} + scheme = quant.get('scheme') + if scheme == 'gguf': + return None + if scheme in ('comfy_quant', 'scaled_fp8'): + fmt = quant.get('format') or '' + return QUANT_PRECISION_TOKENS.get(fmt, re.sub(r'[^a-z0-9]', '', fmt.lower()) or None) + return DTYPE_PRECISION_TOKENS.get(probe.get('dominant_dtype') or '') + + +def probe_safetensors_file(path: str) -> dict: + try: + header = read_safetensors_header(path) + except Exception as e: + return error_result('safetensors', str(e), 'corrupt_header') + result = analyze_header(header) + if result['quant']['scheme'] == 'comfy_quant': + fmt = comfy_marker_format(path) + if fmt: + result['quant']['format'] = fmt + result['quant']['source'] = 'marker' + return result + + +def probe_gguf_file(path: str) -> dict: + try: + from modules.ggml import install_gguf + install_gguf() + import gguf + reader = gguf.GGUFReader(path) + header = {} + for tensor in reader.tensors: + header[str(tensor.name)] = {'dtype': str(tensor.tensor_type.name), 'shape': [int(d) for d in reversed(tensor.shape)]} + arch_metadata = {} + for key in ('general.architecture', 'general.name'): + fld = reader.fields.get(key) + if fld is not None: + try: + arch_metadata[key] = str(bytes(fld.parts[fld.data[0]]).decode('utf-8')) + except Exception: + pass + return analyze_header(header, container='gguf', arch_metadata=arch_metadata) + except Exception as e: + return error_result('gguf', str(e)) + + +probe_cache = None + + +def probe_file(path: str, use_cache: bool = True) -> dict: + """Dispatch by extension with an mtime-validated persistent cache.""" + global probe_cache # pylint: disable=global-statement + ext = os.path.splitext(path)[1].lower() + if ext not in ('.safetensors', '.gguf'): + return error_result('unknown', f'unsupported extension: {ext}', 'unsupported') + try: + stat = os.stat(path) + except OSError as e: + return error_result('unknown', str(e)) + if probe_cache is None: + from modules import paths + from modules.json_helpers import readfile + probe_cache = readfile(paths.probe_cache_file, silent=True, lock=True, as_type='dict') + entry = probe_cache.get(path) if use_cache else None + if entry and entry.get('mtime') == stat.st_mtime and entry.get('size') == stat.st_size and entry.get('schema') == SCHEMA_VERSION: + return entry['probe'] + probe = probe_safetensors_file(path) if ext == '.safetensors' else probe_gguf_file(path) + probe_cache[path] = {'mtime': stat.st_mtime, 'size': stat.st_size, 'schema': SCHEMA_VERSION, 'probe': probe} + return probe + + +def save_probe_cache(): + """Flush the probe cache to disk; call once per scan, not per file.""" + if probe_cache is None: + return + from modules import paths + from modules.json_helpers import writefile + writefile(probe_cache, paths.probe_cache_file, silent=True, atomic=True) diff --git a/modules/paths.py b/modules/paths.py index 050d20d7e..0ed24113b 100644 --- a/modules/paths.py +++ b/modules/paths.py @@ -33,6 +33,8 @@ data_path = cli.data_dir models_config = cli.models_dir or config.get('models_dir') or 'models' models_path = models_config if os.path.isabs(models_config) else os.path.join(data_path, models_config) params_path = os.environ.get('SD_PATH_PARAMS', os.path.join(data_path, "params.txt")) +probe_cache_file = os.path.join(data_path, "data", "signatures.json") +civitai_probe_file = os.path.join(data_path, "data", "civitai.json") extensions_dir = cli.extensions_dir or os.path.join(data_path, "extensions") extensions_builtin_dir = "extensions-builtin" sd_configs_path = os.path.join(script_path, "configs") diff --git a/modules/sd_models.py b/modules/sd_models.py index ce6e37f6a..688e82a20 100644 --- a/modules/sd_models.py +++ b/modules/sd_models.py @@ -331,7 +331,7 @@ def load_diffuser_initial(diffusers_load_config: dict, op='model'): return sd_model, checkpoint_info -def hf_prefetch_configs(checkpoint_info: CheckpointInfo, diffusers_load_config: dict, op='model'): +def hf_prefetch_configs(checkpoint_info: CheckpointInfo | str, diffusers_load_config: dict, op='model'): # diffusers pipeline downloads build subfolder config allow-patterns with os.path.join, and huggingface_hub>=1.22 # matches patterns with fnmatchcase which does not normalize separators (huggingface/huggingface_hub#4435), # so on windows component config.json files are never downloaded and the incomplete snapshot @@ -496,8 +496,8 @@ def load_diffuser_force(detected_model_type: str, checkpoint_info: CheckpointInf sd_model = load_vibe(checkpoint_info, diffusers_load_config) allow_post_quant = False elif model_type in ['JoyEdit']: - from pipelines.model_joy import load_joy - sd_model = load_joy(checkpoint_info, diffusers_load_config) + from pipelines.model_joy import load_joyedit + sd_model = load_joyedit(checkpoint_info, diffusers_load_config) allow_post_quant = False elif model_type in ['Qwen']: from pipelines.model_qwen import load_qwen @@ -932,7 +932,9 @@ def load_diffuser(checkpoint_info: CheckpointInfo | None = None, op='model', rev if model_type is None: log.error(f'Load {op}: pipeline={shared.opts.diffusers_pipeline} not detected') return + hf_prefetch_configs(checkpoint_info, diffusers_load_config, op) + vae_file = None if model_type.startswith('Stable Diffusion') and (op == 'model' or op == 'refiner'): # preload vae for sd models vae_file, vae_source = sd_vae.resolve_vae(checkpoint_info.filename) @@ -1475,8 +1477,9 @@ def reload_model_weights(sd_model=None, info: CheckpointInfo | None = None, op=' loaded_ckpt = getattr(sd_model, 'sd_checkpoint_info', None) if sd_model is not None else None changed_checkpoint = loaded_ckpt is None or checkpoint_info is None or loaded_ckpt.filename != checkpoint_info.filename reset_unet = shared.opts.sd_unet not in (None, 'Default', 'None') + reset_unet_secondary = shared.opts.sd_unet_secondary not in (None, 'Default', 'None') reset_te = shared.opts.sd_text_encoder not in (None, 'Default', 'None') - if op == 'model' and sd_model is not None and changed_checkpoint and (reset_unet or reset_te): + if op == 'model' and sd_model is not None and changed_checkpoint and (reset_unet or reset_unet_secondary or reset_te): # compare detected model type, not pipeline class: custom-loader arches (e.g. Krea2) load as a # concrete class but detect as generic DiffusionPipeline, so a class compare would falsely reset # across same-arch checkpoints (Base vs Turbo). detect both sides so the comparison is symmetric. @@ -1490,6 +1493,10 @@ def reload_model_weights(sd_model=None, info: CheckpointInfo | None = None, op=' log.info(f'Load model: type="{old_type}" changed="{new_type}" unet="{shared.opts.sd_unet}" set to default') shared.opts.data["sd_unet"] = 'Default' sd_unet.loaded_unet = None + if reset_unet_secondary: + log.info(f'Load model: type="{old_type}" changed="{new_type}" unet_secondary="{shared.opts.sd_unet_secondary}" set to default') + shared.opts.data["sd_unet_secondary"] = 'Default' + sd_unet.loaded_unet_secondary = None if reset_te: log.info(f'Load model: type="{old_type}" changed="{new_type}" te="{shared.opts.sd_text_encoder}" set to default') shared.opts.data["sd_text_encoder"] = 'Default' diff --git a/modules/sd_models_utils.py b/modules/sd_models_utils.py index e2df10828..7ff223638 100644 --- a/modules/sd_models_utils.py +++ b/modules/sd_models_utils.py @@ -58,7 +58,7 @@ def get_call(cls): return signature.parameters -def path_to_repo(checkpoint_info): +def path_to_repo(checkpoint_info: CheckpointInfo | str): if isinstance(checkpoint_info, CheckpointInfo): if os.path.exists(checkpoint_info.path) and 'models--' not in checkpoint_info.path: return checkpoint_info.path # local models diff --git a/modules/sd_offload.py b/modules/sd_offload.py index dd143e1ef..c6d2cdc9a 100644 --- a/modules/sd_offload.py +++ b/modules/sd_offload.py @@ -21,8 +21,8 @@ offload_post = ['h1'] offload_hook_instance = None balanced_offload_exclude = ['CogView4Pipeline', 'MeissonicPipeline'] no_split_module_classes = [ - "Linear", "Conv1d", "Conv2d", "Conv3d", "ConvTranspose1d", "ConvTranspose2d", "ConvTranspose3d", - "SDNQLinear", "SDNQConv1d", "SDNQConv2d", "SDNQConv3d", "SDNQConvTranspose1d", "SDNQConvTranspose2d", "SDNQConvTranspose3d", + "Linear", "Conv1d", "Conv2d", "Conv3d", "ConvTranspose1d", "ConvTranspose2d", "ConvTranspose3d", "Embedding", + "SDNQLinear", "SDNQConv1d", "SDNQConv2d", "SDNQConv3d", "SDNQConvTranspose1d", "SDNQConvTranspose2d", "SDNQConvTranspose3d", "SDNQEmbedding", "WanTransformerBlock", ] accelerate_dtype_byte_size = None diff --git a/modules/sd_unet.py b/modules/sd_unet.py index 7072bd019..890662be0 100644 --- a/modules/sd_unet.py +++ b/modules/sd_unet.py @@ -5,11 +5,14 @@ from modules.logger import log unet_dict = {} loaded_unet = None +loaded_unet_secondary = None failed_unet = [] debug = os.environ.get('SD_LOAD_DEBUG', None) is not None dit_models = ['Flux', 'StableDiffusion3', 'HiDream', 'Lumina2', 'Chroma', 'Wan', 'Qwen', 'Anima'] +# model types (shared.sd_model_type keyspace) the secondary UNET override applies to +DUAL_TRANSFORMER_TYPES = ('ideogram4', 'wanai') def load_unet_sdxl_nunchaku(repo_id): @@ -101,6 +104,35 @@ def load_unet(model, repo_id: str | None = None): devices.torch_gc() +def load_unet_secondary(model): # pylint: disable=unused-argument + """Onchange handler for the secondary UNET override: a change means a + full reload; for single-transformer models the selection is stored and + applies on the next dual-transformer load. + """ + global loaded_unet_secondary # pylint: disable=global-statement + selected = shared.opts.sd_unet_secondary + + if selected is None or selected in ('Default', 'None'): + if loaded_unet_secondary in (None, 'Default', 'None'): + return + log.info(f'Load module: type=UNet slot=secondary name="Default" (was="{loaded_unet_secondary}") reverting to base transformer') + loaded_unet_secondary = selected + sd_models.reload_model_weights(force=True) + return + + if selected not in list(unet_dict): + log.error(f'Load module: type=UNet slot=secondary not found: {selected}') + return + if selected == loaded_unet_secondary or selected in failed_unet: + return + if shared.sd_model_type not in DUAL_TRANSFORMER_TYPES: + log.warning(f'Load module: type=UNet slot=secondary name="{selected}" stored: model type={shared.sd_model_type} has a single transformer, applies on next dual-transformer load') + return + loaded_unet_secondary = selected + sd_models.reload_model_weights(force=True) + devices.torch_gc() + + def refresh_unet_list(): unet_dict.clear() for file in files_cache.list_files(shared.opts.unet_dir, ext_filter=[".safetensors", ".gguf", ".pth"]): diff --git a/modules/sdnq/common.py b/modules/sdnq/common.py index d4309da22..6d4031d37 100644 --- a/modules/sdnq/common.py +++ b/modules/sdnq/common.py @@ -4,7 +4,7 @@ import os import json import torch -from modules import shared, devices +from modules import shared sdnq_version = "0.2.2" sdnq_keys = {"weight", "scale", "zero_point", "svd_up", "svd_down"} @@ -62,171 +62,171 @@ dtype_dict = { "float8_e4m3fn": {"min": -448.0, "max": 448.0, "num_bits": 8, "sign": 1, "exponent": 4, "mantissa": 3, "target_dtype": torch.float8_e4m3fn, "torch_dtype": torch.float8_e4m3fn, "storage_dtype": torch.float8_e4m3fn, "is_unsigned": False, "is_integer": False, "is_packed": False}, "float8_e5m2": {"min": -57344.0, "max": 57344.0, "num_bits": 8, "sign": 1, "exponent": 5, "mantissa": 2, "target_dtype": torch.float8_e5m2, "torch_dtype": torch.float8_e5m2, "storage_dtype": torch.float8_e5m2, "is_unsigned": False, "is_integer": False, "is_packed": False}, ### Custom Floats - "float16_e1m14fn": {"min": -3.9998779296875, "max": 3.9998779296875, "num_bits": 16, "sign": 1, "exponent": 1, "mantissa": 14, "min_normal": 1.00006103515625, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float16_e2m13fn": {"min": -7.99951171875, "max": 7.99951171875, "num_bits": 16, "sign": 1, "exponent": 2, "mantissa": 13, "min_normal": 0.50006103515625, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float16_e3m12fn": {"min": -31.99609375, "max": 31.99609375, "num_bits": 16, "sign": 1, "exponent": 3, "mantissa": 12, "min_normal": 0.125030517578125, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float16_e4m11fn": {"min": -511.875, "max": 511.875, "num_bits": 16, "sign": 1, "exponent": 4, "mantissa": 11, "min_normal": 0.007816314697265625, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float16_e5m10fn": {"min": -131008.0, "max": 131008.0, "num_bits": 16, "sign": 1, "exponent": 5, "mantissa": 10, "min_normal": 3.0547380447387695e-05, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float16_e1m14fn": {"min": -3.9998779296875, "max": 3.9998779296875, "num_bits": 16, "sign": 1, "exponent": 1, "mantissa": 14, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float16_e2m13fn": {"min": -7.99951171875, "max": 7.99951171875, "num_bits": 16, "sign": 1, "exponent": 2, "mantissa": 13, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float16_e3m12fn": {"min": -31.99609375, "max": 31.99609375, "num_bits": 16, "sign": 1, "exponent": 3, "mantissa": 12, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float16_e4m11fn": {"min": -511.875, "max": 511.875, "num_bits": 16, "sign": 1, "exponent": 4, "mantissa": 11, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float16_e5m10fn": {"min": -131008.0, "max": 131008.0, "num_bits": 16, "sign": 1, "exponent": 5, "mantissa": 10, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float15_e1m13fn": {"min": -3.999755859375, "max": 3.999755859375, "num_bits": 15, "sign": 1, "exponent": 1, "mantissa": 13, "min_normal": 1.0001220703125, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float15_e2m12fn": {"min": -7.9990234375, "max": 7.9990234375, "num_bits": 15, "sign": 1, "exponent": 2, "mantissa": 12, "min_normal": 0.5001220703125, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float15_e3m11fn": {"min": -31.9921875, "max": 31.9921875, "num_bits": 15, "sign": 1, "exponent": 3, "mantissa": 11, "min_normal": 0.12506103515625, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float15_e4m10fn": {"min": -511.75, "max": 511.75, "num_bits": 15, "sign": 1, "exponent": 4, "mantissa": 10, "min_normal": 0.00782012939453125, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float15_e5m9fn": {"min": -130944.0, "max": 130944.0, "num_bits": 15, "sign": 1, "exponent": 5, "mantissa": 9, "min_normal": 3.057718276977539e-05, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float15_e1m13fn": {"min": -3.999755859375, "max": 3.999755859375, "num_bits": 15, "sign": 1, "exponent": 1, "mantissa": 13, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float15_e2m12fn": {"min": -7.9990234375, "max": 7.9990234375, "num_bits": 15, "sign": 1, "exponent": 2, "mantissa": 12, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float15_e3m11fn": {"min": -31.9921875, "max": 31.9921875, "num_bits": 15, "sign": 1, "exponent": 3, "mantissa": 11, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float15_e4m10fn": {"min": -511.75, "max": 511.75, "num_bits": 15, "sign": 1, "exponent": 4, "mantissa": 10, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float15_e5m9fn": {"min": -130944.0, "max": 130944.0, "num_bits": 15, "sign": 1, "exponent": 5, "mantissa": 9, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float14_e1m12fn": {"min": -3.99951171875, "max": 3.99951171875, "num_bits": 14, "sign": 1, "exponent": 1, "mantissa": 12, "min_normal": 1.000244140625, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float14_e2m11fn": {"min": -7.998046875, "max": 7.998046875, "num_bits": 14, "sign": 1, "exponent": 2, "mantissa": 11, "min_normal": 0.500244140625, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float14_e3m10fn": {"min": -31.984375, "max": 31.984375, "num_bits": 14, "sign": 1, "exponent": 3, "mantissa": 10, "min_normal": 0.1251220703125, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float14_e4m9fn": {"min": -511.5, "max": 511.5, "num_bits": 14, "sign": 1, "exponent": 4, "mantissa": 9, "min_normal": 0.0078277587890625, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float14_e5m8fn": {"min": -130816.0, "max": 130816.0, "num_bits": 14, "sign": 1, "exponent": 5, "mantissa": 8, "min_normal": 3.063678741455078e-05, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float14_e1m12fn": {"min": -3.99951171875, "max": 3.99951171875, "num_bits": 14, "sign": 1, "exponent": 1, "mantissa": 12, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float14_e2m11fn": {"min": -7.998046875, "max": 7.998046875, "num_bits": 14, "sign": 1, "exponent": 2, "mantissa": 11, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float14_e3m10fn": {"min": -31.984375, "max": 31.984375, "num_bits": 14, "sign": 1, "exponent": 3, "mantissa": 10, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float14_e4m9fn": {"min": -511.5, "max": 511.5, "num_bits": 14, "sign": 1, "exponent": 4, "mantissa": 9, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float14_e5m8fn": {"min": -130816.0, "max": 130816.0, "num_bits": 14, "sign": 1, "exponent": 5, "mantissa": 8, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float13_e1m11fn": {"min": -3.9990234375, "max": 3.9990234375, "num_bits": 13, "sign": 1, "exponent": 1, "mantissa": 11, "min_normal": 1.00048828125, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float13_e2m10fn": {"min": -7.99609375, "max": 7.99609375, "num_bits": 13, "sign": 1, "exponent": 2, "mantissa": 10, "min_normal": 0.50048828125, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float13_e3m9fn": {"min": -31.96875, "max": 31.96875, "num_bits": 13, "sign": 1, "exponent": 3, "mantissa": 9, "min_normal": 0.125244140625, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float13_e4m8fn": {"min": -511.0, "max": 511.0, "num_bits": 13, "sign": 1, "exponent": 4, "mantissa": 8, "min_normal": 0.007843017578125, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float13_e5m7fn": {"min": -130560.0, "max": 130560.0, "num_bits": 13, "sign": 1, "exponent": 5, "mantissa": 7, "min_normal": 3.075599670410156e-05, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float13_e1m11fn": {"min": -3.9990234375, "max": 3.9990234375, "num_bits": 13, "sign": 1, "exponent": 1, "mantissa": 11, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float13_e2m10fn": {"min": -7.99609375, "max": 7.99609375, "num_bits": 13, "sign": 1, "exponent": 2, "mantissa": 10, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float13_e3m9fn": {"min": -31.96875, "max": 31.96875, "num_bits": 13, "sign": 1, "exponent": 3, "mantissa": 9, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float13_e4m8fn": {"min": -511.0, "max": 511.0, "num_bits": 13, "sign": 1, "exponent": 4, "mantissa": 8, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float13_e5m7fn": {"min": -130560.0, "max": 130560.0, "num_bits": 13, "sign": 1, "exponent": 5, "mantissa": 7, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float12_e1m10fn": {"min": -3.998046875, "max": 3.998046875, "num_bits": 12, "sign": 1, "exponent": 1, "mantissa": 10, "min_normal": 1.0009765625, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float12_e2m9fn": {"min": -7.9921875, "max": 7.9921875, "num_bits": 12, "sign": 1, "exponent": 2, "mantissa": 9, "min_normal": 0.5009765625, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float12_e3m8fn": {"min": -31.9375, "max": 31.9375, "num_bits": 12, "sign": 1, "exponent": 3, "mantissa": 8, "min_normal": 0.12548828125, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float12_e4m7fn": {"min": -510.0, "max": 510.0, "num_bits": 12, "sign": 1, "exponent": 4, "mantissa": 7, "min_normal": 0.00787353515625, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float12_e5m6fn": {"min": -130048.0, "max": 130048.0, "num_bits": 12, "sign": 1, "exponent": 5, "mantissa": 6, "min_normal": 3.0994415283203125e-05, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float12_e1m10fn": {"min": -3.998046875, "max": 3.998046875, "num_bits": 12, "sign": 1, "exponent": 1, "mantissa": 10, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float12_e2m9fn": {"min": -7.9921875, "max": 7.9921875, "num_bits": 12, "sign": 1, "exponent": 2, "mantissa": 9, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float12_e3m8fn": {"min": -31.9375, "max": 31.9375, "num_bits": 12, "sign": 1, "exponent": 3, "mantissa": 8, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float12_e4m7fn": {"min": -510.0, "max": 510.0, "num_bits": 12, "sign": 1, "exponent": 4, "mantissa": 7, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float12_e5m6fn": {"min": -130048.0, "max": 130048.0, "num_bits": 12, "sign": 1, "exponent": 5, "mantissa": 6, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float11_e1m9fn": {"min": -3.99609375, "max": 3.99609375, "num_bits": 11, "sign": 1, "exponent": 1, "mantissa": 9, "min_normal": 1.001953125, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float11_e2m8fn": {"min": -7.984375, "max": 7.984375, "num_bits": 11, "sign": 1, "exponent": 2, "mantissa": 8, "min_normal": 0.501953125, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float11_e3m7fn": {"min": -31.875, "max": 31.875, "num_bits": 11, "sign": 1, "exponent": 3, "mantissa": 7, "min_normal": 0.1259765625, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float11_e4m6fn": {"min": -508.0, "max": 508.0, "num_bits": 11, "sign": 1, "exponent": 4, "mantissa": 6, "min_normal": 0.0079345703125, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float11_e5m5fn": {"min": -129024.0, "max": 129024.0, "num_bits": 11, "sign": 1, "exponent": 5, "mantissa": 5, "min_normal": 3.147125244140625e-05, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float11_e1m9fn": {"min": -3.99609375, "max": 3.99609375, "num_bits": 11, "sign": 1, "exponent": 1, "mantissa": 9, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float11_e2m8fn": {"min": -7.984375, "max": 7.984375, "num_bits": 11, "sign": 1, "exponent": 2, "mantissa": 8, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float11_e3m7fn": {"min": -31.875, "max": 31.875, "num_bits": 11, "sign": 1, "exponent": 3, "mantissa": 7, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float11_e4m6fn": {"min": -508.0, "max": 508.0, "num_bits": 11, "sign": 1, "exponent": 4, "mantissa": 6, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float11_e5m5fn": {"min": -129024.0, "max": 129024.0, "num_bits": 11, "sign": 1, "exponent": 5, "mantissa": 5, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float10_e1m8fn": {"min": -3.9921875, "max": 3.9921875, "num_bits": 10, "sign": 1, "exponent": 1, "mantissa": 8, "min_normal": 1.00390625, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float10_e2m7fn": {"min": -7.96875, "max": 7.96875, "num_bits": 10, "sign": 1, "exponent": 2, "mantissa": 7, "min_normal": 0.50390625, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float10_e3m6fn": {"min": -31.75, "max": 31.75, "num_bits": 10, "sign": 1, "exponent": 3, "mantissa": 6, "min_normal": 0.126953125, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float10_e4m5fn": {"min": -504.0, "max": 504.0, "num_bits": 10, "sign": 1, "exponent": 4, "mantissa": 5, "min_normal": 0.008056640625, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float10_e5m4fn": {"min": -126976.0, "max": 126976.0, "num_bits": 10, "sign": 1, "exponent": 5, "mantissa": 4, "min_normal": 3.24249267578125e-05, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float10_e1m8fn": {"min": -3.9921875, "max": 3.9921875, "num_bits": 10, "sign": 1, "exponent": 1, "mantissa": 8, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float10_e2m7fn": {"min": -7.96875, "max": 7.96875, "num_bits": 10, "sign": 1, "exponent": 2, "mantissa": 7, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float10_e3m6fn": {"min": -31.75, "max": 31.75, "num_bits": 10, "sign": 1, "exponent": 3, "mantissa": 6, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float10_e4m5fn": {"min": -504.0, "max": 504.0, "num_bits": 10, "sign": 1, "exponent": 4, "mantissa": 5, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float10_e5m4fn": {"min": -126976.0, "max": 126976.0, "num_bits": 10, "sign": 1, "exponent": 5, "mantissa": 4, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float9_e1m7fn": {"min": -3.984375, "max": 3.984375, "num_bits": 9, "sign": 1, "exponent": 1, "mantissa": 7, "min_normal": 1.0078125, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float9_e2m6fn": {"min": -7.9375, "max": 7.9375, "num_bits": 9, "sign": 1, "exponent": 2, "mantissa": 6, "min_normal": 0.5078125, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float9_e3m5fn": {"min": -31.5, "max": 31.5, "num_bits": 9, "sign": 1, "exponent": 3, "mantissa": 5, "min_normal": 0.12890625, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float9_e4m4fn": {"min": -496.0, "max": 496.0, "num_bits": 9, "sign": 1, "exponent": 4, "mantissa": 4, "min_normal": 0.00830078125, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float9_e5m3fn": {"min": -122880.0, "max": 122880.0, "num_bits": 9, "sign": 1, "exponent": 5, "mantissa": 3, "min_normal": 3.4332275390625e-05, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float9_e1m7fn": {"min": -3.984375, "max": 3.984375, "num_bits": 9, "sign": 1, "exponent": 1, "mantissa": 7, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float9_e2m6fn": {"min": -7.9375, "max": 7.9375, "num_bits": 9, "sign": 1, "exponent": 2, "mantissa": 6, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float9_e3m5fn": {"min": -31.5, "max": 31.5, "num_bits": 9, "sign": 1, "exponent": 3, "mantissa": 5, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float9_e4m4fn": {"min": -496.0, "max": 496.0, "num_bits": 9, "sign": 1, "exponent": 4, "mantissa": 4, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float9_e5m3fn": {"min": -122880.0, "max": 122880.0, "num_bits": 9, "sign": 1, "exponent": 5, "mantissa": 3, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float8_e1m6fn": {"min": -3.96875, "max": 3.96875, "num_bits": 8, "sign": 1, "exponent": 1, "mantissa": 6, "min_normal": 1.015625, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float8_e2m5fn": {"min": -7.875, "max": 7.875, "num_bits": 8, "sign": 1, "exponent": 2, "mantissa": 5, "min_normal": 0.515625, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float8_e3m4fn": {"min": -31.0, "max": 31.0, "num_bits": 8, "sign": 1, "exponent": 3, "mantissa": 4, "min_normal": 0.1328125, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float8_e4m3fn_sdnq": {"min": -480.0, "max": 480.0, "num_bits": 8, "sign": 1, "exponent": 4, "mantissa": 3, "min_normal": 0.0087890625, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float8_e5m2fn": {"min": -114688.0, "max": 114688.0, "num_bits": 8, "sign": 1, "exponent": 5, "mantissa": 2, "min_normal": 3.814697265625e-05, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float8_e1m6fn": {"min": -3.96875, "max": 3.96875, "num_bits": 8, "sign": 1, "exponent": 1, "mantissa": 6, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float8_e2m5fn": {"min": -7.875, "max": 7.875, "num_bits": 8, "sign": 1, "exponent": 2, "mantissa": 5, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float8_e3m4fn": {"min": -31.0, "max": 31.0, "num_bits": 8, "sign": 1, "exponent": 3, "mantissa": 4, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float8_e4m3fn_sdnq": {"min": -480.0, "max": 480.0, "num_bits": 8, "sign": 1, "exponent": 4, "mantissa": 3, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float8_e5m2fn": {"min": -114688.0, "max": 114688.0, "num_bits": 8, "sign": 1, "exponent": 5, "mantissa": 2, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float7_e1m5fn": {"min": -3.9375, "max": 3.9375, "num_bits": 7, "sign": 1, "exponent": 1, "mantissa": 5, "min_normal": 1.03125, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float7_e2m4fn": {"min": -7.75, "max": 7.75, "num_bits": 7, "sign": 1, "exponent": 2, "mantissa": 4, "min_normal": 0.53125, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float7_e3m3fn": {"min": -30.0, "max": 30.0, "num_bits": 7, "sign": 1, "exponent": 3, "mantissa": 3, "min_normal": 0.140625, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float7_e4m2fn": {"min": -448.0, "max": 448.0, "num_bits": 7, "sign": 1, "exponent": 4, "mantissa": 2, "min_normal": 0.009765625, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float7_e5m1fn": {"min": -98304.0, "max": 98304.0, "num_bits": 7, "sign": 1, "exponent": 5, "mantissa": 1, "min_normal": 4.57763671875e-05, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float7_e1m5fn": {"min": -3.9375, "max": 3.9375, "num_bits": 7, "sign": 1, "exponent": 1, "mantissa": 5, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float7_e2m4fn": {"min": -7.75, "max": 7.75, "num_bits": 7, "sign": 1, "exponent": 2, "mantissa": 4, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float7_e3m3fn": {"min": -30.0, "max": 30.0, "num_bits": 7, "sign": 1, "exponent": 3, "mantissa": 3, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float7_e4m2fn": {"min": -448.0, "max": 448.0, "num_bits": 7, "sign": 1, "exponent": 4, "mantissa": 2, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float7_e5m1fn": {"min": -98304.0, "max": 98304.0, "num_bits": 7, "sign": 1, "exponent": 5, "mantissa": 1, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float6_e1m4fn": {"min": -3.875, "max": 3.875, "num_bits": 6, "sign": 1, "exponent": 1, "mantissa": 4, "min_normal": 1.0625, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float6_e2m3fn": {"min": -7.5, "max": 7.5, "num_bits": 6, "sign": 1, "exponent": 2, "mantissa": 3, "min_normal": 0.5625, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float6_e3m2fn": {"min": -28.0, "max": 28.0, "num_bits": 6, "sign": 1, "exponent": 3, "mantissa": 2, "min_normal": 0.15625, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float6_e4m1fn": {"min": -384.0, "max": 384.0, "num_bits": 6, "sign": 1, "exponent": 4, "mantissa": 1, "min_normal": 0.01171875, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float6_e5m0fn": {"min": -65536.0, "max": 65536.0, "num_bits": 6, "sign": 1, "exponent": 5, "mantissa": 0, "min_normal": 6.103515625e-05, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float6_e1m4fn": {"min": -3.875, "max": 3.875, "num_bits": 6, "sign": 1, "exponent": 1, "mantissa": 4, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float6_e2m3fn": {"min": -7.5, "max": 7.5, "num_bits": 6, "sign": 1, "exponent": 2, "mantissa": 3, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float6_e3m2fn": {"min": -28.0, "max": 28.0, "num_bits": 6, "sign": 1, "exponent": 3, "mantissa": 2, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float6_e4m1fn": {"min": -384.0, "max": 384.0, "num_bits": 6, "sign": 1, "exponent": 4, "mantissa": 1, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float6_e5m0fn": {"min": -65536.0, "max": 65536.0, "num_bits": 6, "sign": 1, "exponent": 5, "mantissa": 0, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float5_e1m3fn": {"min": -3.75, "max": 3.75, "num_bits": 5, "sign": 1, "exponent": 1, "mantissa": 3, "min_normal": 1.125, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float5_e2m2fn": {"min": -7.0, "max": 7.0, "num_bits": 5, "sign": 1, "exponent": 2, "mantissa": 2, "min_normal": 0.625, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float5_e3m1fn": {"min": -24.0, "max": 24.0, "num_bits": 5, "sign": 1, "exponent": 3, "mantissa": 1, "min_normal": 0.1875, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float5_e4m0fn": {"min": -256.0, "max": 256.0, "num_bits": 5, "sign": 1, "exponent": 4, "mantissa": 0, "min_normal": 0.015625, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float5_e1m3fn": {"min": -3.75, "max": 3.75, "num_bits": 5, "sign": 1, "exponent": 1, "mantissa": 3, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float5_e2m2fn": {"min": -7.0, "max": 7.0, "num_bits": 5, "sign": 1, "exponent": 2, "mantissa": 2, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float5_e3m1fn": {"min": -24.0, "max": 24.0, "num_bits": 5, "sign": 1, "exponent": 3, "mantissa": 1, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float5_e4m0fn": {"min": -256.0, "max": 256.0, "num_bits": 5, "sign": 1, "exponent": 4, "mantissa": 0, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float4_e1m2fn": {"min": -3.5, "max": 3.5, "num_bits": 4, "sign": 1, "exponent": 1, "mantissa": 2, "min_normal": 1.25, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float4_e2m1fn": {"min": -6.0, "max": 6.0, "num_bits": 4, "sign": 1, "exponent": 2, "mantissa": 1, "min_normal": 0.75, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float4_e3m0fn": {"min": -16.0, "max": 16.0, "num_bits": 4, "sign": 1, "exponent": 3, "mantissa": 0, "min_normal": 0.25, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float4_e1m2fn": {"min": -3.5, "max": 3.5, "num_bits": 4, "sign": 1, "exponent": 1, "mantissa": 2, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float4_e2m1fn": {"min": -6.0, "max": 6.0, "num_bits": 4, "sign": 1, "exponent": 2, "mantissa": 1, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float4_e3m0fn": {"min": -16.0, "max": 16.0, "num_bits": 4, "sign": 1, "exponent": 3, "mantissa": 0, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float3_e1m1fn": {"min": -3.0, "max": 3.0, "num_bits": 3, "sign": 1, "exponent": 1, "mantissa": 1, "min_normal": 1.5, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, - "float3_e2m0fn": {"min": -4.0, "max": 4.0, "num_bits": 3, "sign": 1, "exponent": 2, "mantissa": 0, "min_normal": 1.0, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float3_e1m1fn": {"min": -3.0, "max": 3.0, "num_bits": 3, "sign": 1, "exponent": 1, "mantissa": 1, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float3_e2m0fn": {"min": -4.0, "max": 4.0, "num_bits": 3, "sign": 1, "exponent": 2, "mantissa": 0, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, # - "float2_e1m0fn": {"min": -2.0, "max": 2.0, "num_bits": 2, "sign": 1, "exponent": 1, "mantissa": 0, "min_normal": 2.0, "target_dtype": "fp2", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, + "float2_e1m0fn": {"min": -2.0, "max": 2.0, "num_bits": 2, "sign": 1, "exponent": 1, "mantissa": 0, "target_dtype": "fp2", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": False, "is_integer": False, "is_packed": True}, ### Custom Unsigned Floats - "float16_e1m15fnu": {"min": 0, "max": 3.99993896484375, "num_bits": 16, "sign": 0, "exponent": 1, "mantissa": 15, "min_normal": 1.000030517578125, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float16_e2m14fnu": {"min": 0, "max": 7.999755859375, "num_bits": 16, "sign": 0, "exponent": 2, "mantissa": 14, "min_normal": 0.500030517578125, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float16_e3m13fnu": {"min": 0, "max": 31.998046875, "num_bits": 16, "sign": 0, "exponent": 3, "mantissa": 13, "min_normal": 0.1250152587890625, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float16_e4m12fnu": {"min": 0, "max": 511.9375, "num_bits": 16, "sign": 0, "exponent": 4, "mantissa": 12, "min_normal": 0.007814407348632812, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float16_e5m11fnu": {"min": 0, "max": 131040.0, "num_bits": 16, "sign": 0, "exponent": 5, "mantissa": 11, "min_normal": 3.053247928619385e-05, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float16_e1m15fnu": {"min": 0, "max": 3.99993896484375, "num_bits": 16, "sign": 0, "exponent": 1, "mantissa": 15, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float16_e2m14fnu": {"min": 0, "max": 7.999755859375, "num_bits": 16, "sign": 0, "exponent": 2, "mantissa": 14, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float16_e3m13fnu": {"min": 0, "max": 31.998046875, "num_bits": 16, "sign": 0, "exponent": 3, "mantissa": 13, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float16_e4m12fnu": {"min": 0, "max": 511.9375, "num_bits": 16, "sign": 0, "exponent": 4, "mantissa": 12, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float16_e5m11fnu": {"min": 0, "max": 131040.0, "num_bits": 16, "sign": 0, "exponent": 5, "mantissa": 11, "target_dtype": "fp16", "torch_dtype": torch.float32, "storage_dtype": torch.uint16, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float15_e1m14fnu": {"min": 0, "max": 3.9998779296875, "num_bits": 15, "sign": 0, "exponent": 1, "mantissa": 14, "min_normal": 1.00006103515625, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float15_e2m13fnu": {"min": 0, "max": 7.99951171875, "num_bits": 15, "sign": 0, "exponent": 2, "mantissa": 13, "min_normal": 0.50006103515625, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float15_e3m12fnu": {"min": 0, "max": 31.99609375, "num_bits": 15, "sign": 0, "exponent": 3, "mantissa": 12, "min_normal": 0.125030517578125, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float15_e4m11fnu": {"min": 0, "max": 511.875, "num_bits": 15, "sign": 0, "exponent": 4, "mantissa": 11, "min_normal": 0.007816314697265625, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float15_e5m10fnu": {"min": 0, "max": 131008.0, "num_bits": 15, "sign": 0, "exponent": 5, "mantissa": 10, "min_normal": 3.0547380447387695e-05, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float15_e1m14fnu": {"min": 0, "max": 3.9998779296875, "num_bits": 15, "sign": 0, "exponent": 1, "mantissa": 14, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float15_e2m13fnu": {"min": 0, "max": 7.99951171875, "num_bits": 15, "sign": 0, "exponent": 2, "mantissa": 13, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float15_e3m12fnu": {"min": 0, "max": 31.99609375, "num_bits": 15, "sign": 0, "exponent": 3, "mantissa": 12, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float15_e4m11fnu": {"min": 0, "max": 511.875, "num_bits": 15, "sign": 0, "exponent": 4, "mantissa": 11, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float15_e5m10fnu": {"min": 0, "max": 131008.0, "num_bits": 15, "sign": 0, "exponent": 5, "mantissa": 10, "target_dtype": "fp15", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float14_e1m13fnu": {"min": 0, "max": 3.999755859375, "num_bits": 14, "sign": 0, "exponent": 1, "mantissa": 13, "min_normal": 1.0001220703125, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float14_e2m12fnu": {"min": 0, "max": 7.9990234375, "num_bits": 14, "sign": 0, "exponent": 2, "mantissa": 12, "min_normal": 0.5001220703125, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float14_e3m11fnu": {"min": 0, "max": 31.9921875, "num_bits": 14, "sign": 0, "exponent": 3, "mantissa": 11, "min_normal": 0.12506103515625, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float14_e4m10fnu": {"min": 0, "max": 511.75, "num_bits": 14, "sign": 0, "exponent": 4, "mantissa": 10, "min_normal": 0.00782012939453125, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float14_e5m9fnu": {"min": 0, "max": 130944.0, "num_bits": 14, "sign": 0, "exponent": 5, "mantissa": 9, "min_normal": 3.057718276977539e-05, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float14_e1m13fnu": {"min": 0, "max": 3.999755859375, "num_bits": 14, "sign": 0, "exponent": 1, "mantissa": 13, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float14_e2m12fnu": {"min": 0, "max": 7.9990234375, "num_bits": 14, "sign": 0, "exponent": 2, "mantissa": 12, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float14_e3m11fnu": {"min": 0, "max": 31.9921875, "num_bits": 14, "sign": 0, "exponent": 3, "mantissa": 11, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float14_e4m10fnu": {"min": 0, "max": 511.75, "num_bits": 14, "sign": 0, "exponent": 4, "mantissa": 10, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float14_e5m9fnu": {"min": 0, "max": 130944.0, "num_bits": 14, "sign": 0, "exponent": 5, "mantissa": 9, "target_dtype": "fp14", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float13_e1m12fnu": {"min": 0, "max": 3.99951171875, "num_bits": 13, "sign": 0, "exponent": 1, "mantissa": 12, "min_normal": 1.000244140625, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float13_e2m11fnu": {"min": 0, "max": 7.998046875, "num_bits": 13, "sign": 0, "exponent": 2, "mantissa": 11, "min_normal": 0.500244140625, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float13_e3m10fnu": {"min": 0, "max": 31.984375, "num_bits": 13, "sign": 0, "exponent": 3, "mantissa": 10, "min_normal": 0.1251220703125, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float13_e4m9fnu": {"min": 0, "max": 511.5, "num_bits": 13, "sign": 0, "exponent": 4, "mantissa": 9, "min_normal": 0.0078277587890625, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float13_e5m8fnu": {"min": 0, "max": 130816.0, "num_bits": 13, "sign": 0, "exponent": 5, "mantissa": 8, "min_normal": 3.063678741455078e-05, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float13_e1m12fnu": {"min": 0, "max": 3.99951171875, "num_bits": 13, "sign": 0, "exponent": 1, "mantissa": 12, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float13_e2m11fnu": {"min": 0, "max": 7.998046875, "num_bits": 13, "sign": 0, "exponent": 2, "mantissa": 11, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float13_e3m10fnu": {"min": 0, "max": 31.984375, "num_bits": 13, "sign": 0, "exponent": 3, "mantissa": 10, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float13_e4m9fnu": {"min": 0, "max": 511.5, "num_bits": 13, "sign": 0, "exponent": 4, "mantissa": 9, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float13_e5m8fnu": {"min": 0, "max": 130816.0, "num_bits": 13, "sign": 0, "exponent": 5, "mantissa": 8, "target_dtype": "fp13", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float12_e1m11fnu": {"min": 0, "max": 3.9990234375, "num_bits": 12, "sign": 0, "exponent": 1, "mantissa": 11, "min_normal": 1.00048828125, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float12_e2m10fnu": {"min": 0, "max": 7.99609375, "num_bits": 12, "sign": 0, "exponent": 2, "mantissa": 10, "min_normal": 0.50048828125, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float12_e3m9fnu": {"min": 0, "max": 31.96875, "num_bits": 12, "sign": 0, "exponent": 3, "mantissa": 9, "min_normal": 0.125244140625, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float12_e4m8fnu": {"min": 0, "max": 511.0, "num_bits": 12, "sign": 0, "exponent": 4, "mantissa": 8, "min_normal": 0.007843017578125, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float12_e5m7fnu": {"min": 0, "max": 130560.0, "num_bits": 12, "sign": 0, "exponent": 5, "mantissa": 7, "min_normal": 3.075599670410156e-05, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float12_e1m11fnu": {"min": 0, "max": 3.9990234375, "num_bits": 12, "sign": 0, "exponent": 1, "mantissa": 11, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float12_e2m10fnu": {"min": 0, "max": 7.99609375, "num_bits": 12, "sign": 0, "exponent": 2, "mantissa": 10, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float12_e3m9fnu": {"min": 0, "max": 31.96875, "num_bits": 12, "sign": 0, "exponent": 3, "mantissa": 9, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float12_e4m8fnu": {"min": 0, "max": 511.0, "num_bits": 12, "sign": 0, "exponent": 4, "mantissa": 8, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float12_e5m7fnu": {"min": 0, "max": 130560.0, "num_bits": 12, "sign": 0, "exponent": 5, "mantissa": 7, "target_dtype": "fp12", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float11_e1m10fnu": {"min": 0, "max": 3.998046875, "num_bits": 11, "sign": 0, "exponent": 1, "mantissa": 10, "min_normal": 1.0009765625, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float11_e2m9fnu": {"min": 0, "max": 7.9921875, "num_bits": 11, "sign": 0, "exponent": 2, "mantissa": 9, "min_normal": 0.5009765625, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float11_e3m8fnu": {"min": 0, "max": 31.9375, "num_bits": 11, "sign": 0, "exponent": 3, "mantissa": 8, "min_normal": 0.12548828125, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float11_e4m7fnu": {"min": 0, "max": 510.0, "num_bits": 11, "sign": 0, "exponent": 4, "mantissa": 7, "min_normal": 0.00787353515625, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float11_e5m6fnu": {"min": 0, "max": 130048.0, "num_bits": 11, "sign": 0, "exponent": 5, "mantissa": 6, "min_normal": 3.0994415283203125e-05, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float11_e1m10fnu": {"min": 0, "max": 3.998046875, "num_bits": 11, "sign": 0, "exponent": 1, "mantissa": 10, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float11_e2m9fnu": {"min": 0, "max": 7.9921875, "num_bits": 11, "sign": 0, "exponent": 2, "mantissa": 9, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float11_e3m8fnu": {"min": 0, "max": 31.9375, "num_bits": 11, "sign": 0, "exponent": 3, "mantissa": 8, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float11_e4m7fnu": {"min": 0, "max": 510.0, "num_bits": 11, "sign": 0, "exponent": 4, "mantissa": 7, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float11_e5m6fnu": {"min": 0, "max": 130048.0, "num_bits": 11, "sign": 0, "exponent": 5, "mantissa": 6, "target_dtype": "fp11", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float10_e1m9fnu": {"min": 0, "max": 3.99609375, "num_bits": 10, "sign": 0, "exponent": 1, "mantissa": 9, "min_normal": 1.001953125, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float10_e2m8fnu": {"min": 0, "max": 7.984375, "num_bits": 10, "sign": 0, "exponent": 2, "mantissa": 8, "min_normal": 0.501953125, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float10_e3m7fnu": {"min": 0, "max": 31.875, "num_bits": 10, "sign": 0, "exponent": 3, "mantissa": 7, "min_normal": 0.1259765625, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float10_e4m6fnu": {"min": 0, "max": 508.0, "num_bits": 10, "sign": 0, "exponent": 4, "mantissa": 6, "min_normal": 0.0079345703125, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float10_e5m5fnu": {"min": 0, "max": 129024.0, "num_bits": 10, "sign": 0, "exponent": 5, "mantissa": 5, "min_normal": 3.147125244140625e-05, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float10_e1m9fnu": {"min": 0, "max": 3.99609375, "num_bits": 10, "sign": 0, "exponent": 1, "mantissa": 9, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float10_e2m8fnu": {"min": 0, "max": 7.984375, "num_bits": 10, "sign": 0, "exponent": 2, "mantissa": 8, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float10_e3m7fnu": {"min": 0, "max": 31.875, "num_bits": 10, "sign": 0, "exponent": 3, "mantissa": 7, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float10_e4m6fnu": {"min": 0, "max": 508.0, "num_bits": 10, "sign": 0, "exponent": 4, "mantissa": 6, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float10_e5m5fnu": {"min": 0, "max": 129024.0, "num_bits": 10, "sign": 0, "exponent": 5, "mantissa": 5, "target_dtype": "fp10", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float9_e1m8fnu": {"min": 0, "max": 3.9921875, "num_bits": 9, "sign": 0, "exponent": 1, "mantissa": 8, "min_normal": 1.00390625, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float9_e2m7fnu": {"min": 0, "max": 7.96875, "num_bits": 9, "sign": 0, "exponent": 2, "mantissa": 7, "min_normal": 0.50390625, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float9_e3m6fnu": {"min": 0, "max": 31.75, "num_bits": 9, "sign": 0, "exponent": 3, "mantissa": 6, "min_normal": 0.126953125, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float9_e4m5fnu": {"min": 0, "max": 504.0, "num_bits": 9, "sign": 0, "exponent": 4, "mantissa": 5, "min_normal": 0.008056640625, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float9_e5m4fnu": {"min": 0, "max": 126976.0, "num_bits": 9, "sign": 0, "exponent": 5, "mantissa": 4, "min_normal": 3.24249267578125e-05, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float9_e1m8fnu": {"min": 0, "max": 3.9921875, "num_bits": 9, "sign": 0, "exponent": 1, "mantissa": 8, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float9_e2m7fnu": {"min": 0, "max": 7.96875, "num_bits": 9, "sign": 0, "exponent": 2, "mantissa": 7, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float9_e3m6fnu": {"min": 0, "max": 31.75, "num_bits": 9, "sign": 0, "exponent": 3, "mantissa": 6, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float9_e4m5fnu": {"min": 0, "max": 504.0, "num_bits": 9, "sign": 0, "exponent": 4, "mantissa": 5, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float9_e5m4fnu": {"min": 0, "max": 126976.0, "num_bits": 9, "sign": 0, "exponent": 5, "mantissa": 4, "target_dtype": "fp9", "torch_dtype": torch.float32, "storage_dtype": torch.int16, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float8_e1m7fnu": {"min": 0, "max": 3.984375, "num_bits": 8, "sign": 0, "exponent": 1, "mantissa": 7, "min_normal": 1.0078125, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float8_e2m6fnu": {"min": 0, "max": 7.9375, "num_bits": 8, "sign": 0, "exponent": 2, "mantissa": 6, "min_normal": 0.5078125, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float8_e3m5fnu": {"min": 0, "max": 31.5, "num_bits": 8, "sign": 0, "exponent": 3, "mantissa": 5, "min_normal": 0.12890625, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float8_e4m4fnu": {"min": 0, "max": 496.0, "num_bits": 8, "sign": 0, "exponent": 4, "mantissa": 4, "min_normal": 0.00830078125, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float8_e5m3fnu": {"min": 0, "max": 122880.0, "num_bits": 8, "sign": 0, "exponent": 5, "mantissa": 3, "min_normal": 3.4332275390625e-05, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float8_e1m7fnu": {"min": 0, "max": 3.984375, "num_bits": 8, "sign": 0, "exponent": 1, "mantissa": 7, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float8_e2m6fnu": {"min": 0, "max": 7.9375, "num_bits": 8, "sign": 0, "exponent": 2, "mantissa": 6, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float8_e3m5fnu": {"min": 0, "max": 31.5, "num_bits": 8, "sign": 0, "exponent": 3, "mantissa": 5, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float8_e4m4fnu": {"min": 0, "max": 496.0, "num_bits": 8, "sign": 0, "exponent": 4, "mantissa": 4, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float8_e5m3fnu": {"min": 0, "max": 122880.0, "num_bits": 8, "sign": 0, "exponent": 5, "mantissa": 3, "target_dtype": "fp8", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float7_e1m6fnu": {"min": 0, "max": 3.96875, "num_bits": 7, "sign": 0, "exponent": 1, "mantissa": 6, "min_normal": 1.015625, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float7_e2m5fnu": {"min": 0, "max": 7.875, "num_bits": 7, "sign": 0, "exponent": 2, "mantissa": 5, "min_normal": 0.515625, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float7_e3m4fnu": {"min": 0, "max": 31.0, "num_bits": 7, "sign": 0, "exponent": 3, "mantissa": 4, "min_normal": 0.1328125, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float7_e4m3fnu": {"min": 0, "max": 480.0, "num_bits": 7, "sign": 0, "exponent": 4, "mantissa": 3, "min_normal": 0.0087890625, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float7_e5m2fnu": {"min": 0, "max": 114688.0, "num_bits": 7, "sign": 0, "exponent": 5, "mantissa": 2, "min_normal": 3.814697265625e-05, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float7_e1m6fnu": {"min": 0, "max": 3.96875, "num_bits": 7, "sign": 0, "exponent": 1, "mantissa": 6, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float7_e2m5fnu": {"min": 0, "max": 7.875, "num_bits": 7, "sign": 0, "exponent": 2, "mantissa": 5, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float7_e3m4fnu": {"min": 0, "max": 31.0, "num_bits": 7, "sign": 0, "exponent": 3, "mantissa": 4, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float7_e4m3fnu": {"min": 0, "max": 480.0, "num_bits": 7, "sign": 0, "exponent": 4, "mantissa": 3, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float7_e5m2fnu": {"min": 0, "max": 114688.0, "num_bits": 7, "sign": 0, "exponent": 5, "mantissa": 2, "target_dtype": "fp7", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float6_e1m5fnu": {"min": 0, "max": 3.9375, "num_bits": 6, "sign": 0, "exponent": 1, "mantissa": 5, "min_normal": 1.03125, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float6_e2m4fnu": {"min": 0, "max": 7.75, "num_bits": 6, "sign": 0, "exponent": 2, "mantissa": 4, "min_normal": 0.53125, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float6_e3m3fnu": {"min": 0, "max": 30.0, "num_bits": 6, "sign": 0, "exponent": 3, "mantissa": 3, "min_normal": 0.140625, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float6_e4m2fnu": {"min": 0, "max": 448.0, "num_bits": 6, "sign": 0, "exponent": 4, "mantissa": 2, "min_normal": 0.009765625, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float6_e5m1fnu": {"min": 0, "max": 98304.0, "num_bits": 6, "sign": 0, "exponent": 5, "mantissa": 1, "min_normal": 4.57763671875e-05, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float6_e1m5fnu": {"min": 0, "max": 3.9375, "num_bits": 6, "sign": 0, "exponent": 1, "mantissa": 5, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float6_e2m4fnu": {"min": 0, "max": 7.75, "num_bits": 6, "sign": 0, "exponent": 2, "mantissa": 4, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float6_e3m3fnu": {"min": 0, "max": 30.0, "num_bits": 6, "sign": 0, "exponent": 3, "mantissa": 3, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float6_e4m2fnu": {"min": 0, "max": 448.0, "num_bits": 6, "sign": 0, "exponent": 4, "mantissa": 2, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float6_e5m1fnu": {"min": 0, "max": 98304.0, "num_bits": 6, "sign": 0, "exponent": 5, "mantissa": 1, "target_dtype": "fp6", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float5_e1m4fnu": {"min": 0, "max": 3.875, "num_bits": 5, "sign": 0, "exponent": 1, "mantissa": 4, "min_normal": 1.0625, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float5_e2m3fnu": {"min": 0, "max": 7.5, "num_bits": 5, "sign": 0, "exponent": 2, "mantissa": 3, "min_normal": 0.5625, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float5_e3m2fnu": {"min": 0, "max": 28.0, "num_bits": 5, "sign": 0, "exponent": 3, "mantissa": 2, "min_normal": 0.15625, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float5_e4m1fnu": {"min": 0, "max": 384.0, "num_bits": 5, "sign": 0, "exponent": 4, "mantissa": 1, "min_normal": 0.01171875, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float5_e5m0fnu": {"min": 0, "max": 65536.0, "num_bits": 5, "sign": 0, "exponent": 5, "mantissa": 0, "min_normal": 6.103515625e-05, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float5_e1m4fnu": {"min": 0, "max": 3.875, "num_bits": 5, "sign": 0, "exponent": 1, "mantissa": 4, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float5_e2m3fnu": {"min": 0, "max": 7.5, "num_bits": 5, "sign": 0, "exponent": 2, "mantissa": 3, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float5_e3m2fnu": {"min": 0, "max": 28.0, "num_bits": 5, "sign": 0, "exponent": 3, "mantissa": 2, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float5_e4m1fnu": {"min": 0, "max": 384.0, "num_bits": 5, "sign": 0, "exponent": 4, "mantissa": 1, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float5_e5m0fnu": {"min": 0, "max": 65536.0, "num_bits": 5, "sign": 0, "exponent": 5, "mantissa": 0, "target_dtype": "fp5", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float4_e1m3fnu": {"min": 0, "max": 3.75, "num_bits": 4, "sign": 0, "exponent": 1, "mantissa": 3, "min_normal": 1.125, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float4_e2m2fnu": {"min": 0, "max": 7.0, "num_bits": 4, "sign": 0, "exponent": 2, "mantissa": 2, "min_normal": 0.625, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float4_e3m1fnu": {"min": 0, "max": 24.0, "num_bits": 4, "sign": 0, "exponent": 3, "mantissa": 1, "min_normal": 0.1875, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float4_e4m0fnu": {"min": 0, "max": 256.0, "num_bits": 4, "sign": 0, "exponent": 4, "mantissa": 0, "min_normal": 0.015625, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float4_e1m3fnu": {"min": 0, "max": 3.75, "num_bits": 4, "sign": 0, "exponent": 1, "mantissa": 3, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float4_e2m2fnu": {"min": 0, "max": 7.0, "num_bits": 4, "sign": 0, "exponent": 2, "mantissa": 2, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float4_e3m1fnu": {"min": 0, "max": 24.0, "num_bits": 4, "sign": 0, "exponent": 3, "mantissa": 1, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float4_e4m0fnu": {"min": 0, "max": 256.0, "num_bits": 4, "sign": 0, "exponent": 4, "mantissa": 0, "target_dtype": "fp4", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float3_e1m2fnu": {"min": 0, "max": 3.5, "num_bits": 3, "sign": 0, "exponent": 1, "mantissa": 2, "min_normal": 1.25, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float3_e2m1fnu": {"min": 0, "max": 6.0, "num_bits": 3, "sign": 0, "exponent": 2, "mantissa": 1, "min_normal": 0.75, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float3_e3m0fnu": {"min": 0, "max": 16.0, "num_bits": 3, "sign": 0, "exponent": 3, "mantissa": 0, "min_normal": 0.25, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float3_e1m2fnu": {"min": 0, "max": 3.5, "num_bits": 3, "sign": 0, "exponent": 1, "mantissa": 2, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float3_e2m1fnu": {"min": 0, "max": 6.0, "num_bits": 3, "sign": 0, "exponent": 2, "mantissa": 1, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float3_e3m0fnu": {"min": 0, "max": 16.0, "num_bits": 3, "sign": 0, "exponent": 3, "mantissa": 0, "target_dtype": "fp3", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float2_e1m1fnu": {"min": 0, "max": 3.0, "num_bits": 2, "sign": 0, "exponent": 1, "mantissa": 1, "min_normal": 1.5, "target_dtype": "fp2", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, - "float2_e2m0fnu": {"min": 0, "max": 4.0, "num_bits": 2, "sign": 0, "exponent": 2, "mantissa": 0, "min_normal": 1.0, "target_dtype": "fp2", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float2_e1m1fnu": {"min": 0, "max": 3.0, "num_bits": 2, "sign": 0, "exponent": 1, "mantissa": 1, "target_dtype": "fp2", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float2_e2m0fnu": {"min": 0, "max": 4.0, "num_bits": 2, "sign": 0, "exponent": 2, "mantissa": 0, "target_dtype": "fp2", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, # - "float1_e1m0fnu": {"min": 0, "max": 2.0, "num_bits": 1, "sign": 0, "exponent": 1, "mantissa": 0, "min_normal": 2.0, "target_dtype": "fp1", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, + "float1_e1m0fnu": {"min": 0, "max": 2.0, "num_bits": 1, "sign": 0, "exponent": 1, "mantissa": 0, "target_dtype": "fp1", "torch_dtype": torch.float32, "storage_dtype": torch.uint8, "is_unsigned": True, "is_integer": False, "is_packed": True}, } dtype_dict["fp32"] = dtype_dict["float32"] @@ -335,98 +335,12 @@ weights_dtype_order = [ "uint16", "float16_e1m15fnu", "float16_e2m14fnu", "float16_e3m13fnu", "float16_e4m12fnu", "float16_e5m11fnu", ] + use_torch_compile = shared.opts.sdnq_dequantize_compile # this setting requires a full restart of the webui to apply def check_torch_compile() -> bool: # dynamo can be disabled after startup return use_torch_compile and not torch._dynamo.config.disable # pylint: disable=protected-access - -if devices.backend == "rocm": - gfx_version = devices.get_hip_agent().gfx_version - is_rdna2_and_older = bool(gfx_version < 0x940 or (gfx_version < 0x1100 and gfx_version >= 0x1000)) -else: - is_rdna2_and_older = False - -if os.environ.get("SDNQ_ALLOW_FP8_MM", None) is None: - if devices.backend == "cuda": - is_fp8_mm_supported = bool(torch.cuda.get_device_capability(devices.device) >= (8,9)) - elif devices.backend == "rocm": - gfx_version = devices.get_hip_agent().gfx_version - is_fp8_mm_supported = bool(gfx_version >= 0x1200 or (gfx_version >= 0x940 and gfx_version < 0x1000)) - else: - is_fp8_mm_supported = False -else: - is_fp8_mm_supported = os.environ.get("SDNQ_ALLOW_FP8_MM", "0").lower() not in {"0", "false", "no"} - -if os.environ.get("SDNQ_USE_OPENVINO_MM", None) is None: - use_openvino_mm = bool(devices.backend in {"cpu", "openvino"}) -else: - use_openvino_mm = bool(os.environ.get("SDNQ_USE_OPENVINO_MM", "0").lower() not in {"0", "false", "no"}) - -if os.environ.get("SDNQ_USE_TRITON_MM", None) is None: - use_triton_mm = bool(is_rdna2_and_older or devices.backend == "zluda") -else: - use_triton_mm = bool(os.environ.get("SDNQ_USE_TRITON_MM", "0").lower() not in {"0", "false", "no"}) - -if os.environ.get("SDNQ_USE_TENSORWISE_FP8_MM", None) is None: - # row-wise FP8 only exist on H100 hardware, sdnq will use software row-wise with tensorwise hardware with this setting - use_tensorwise_fp8_matmul = bool(devices.backend != "cuda" or (devices.backend == "cuda" and torch.cuda.get_device_capability(devices.device) < (9,0))) -else: - use_tensorwise_fp8_matmul = os.environ.get("SDNQ_USE_TENSORWISE_FP8_MM", "0").lower() not in {"0", "false", "no"} - - -fp_mm_func = None -int_mm_func = None - -if use_openvino_mm: - try: - from .kernels.openvino_mm import openvino_int_mm, openvino_fp_mm - int_mm_func = openvino_int_mm - fp_mm_func = openvino_fp_mm - except Exception: - use_openvino_mm = False -elif use_triton_mm: - try: - from .kernels.triton_mm import triton_int_mm, triton_fp_mm - int_mm_func = triton_int_mm - fp_mm_func = triton_fp_mm - except Exception: - use_triton_mm = False - -if fp_mm_func is None and os.environ.get("SDNQ_USE_TRITON_MM", "1").lower() not in {"0", "false", "no"}: - try: - from .triton_mm import triton_fp_mm - fp_mm_func = triton_fp_mm - except Exception: - use_triton_mm = False - -if int_mm_func is None: - int_mm_func = torch._int_mm -if fp_mm_func is None: - if devices.backend == "cuda": - def fp_mm_torch(x: torch.Tensor, y: torch.Tensor) -> torch.FloatTensor: - return torch.mm(x,y, out_dtype=torch.float32) - else: - def fp_mm_torch(x: torch.Tensor, y: torch.Tensor) -> torch.FloatTensor: - if y.dtype == torch.float8_e4m3fn: - fp16_scale = 4 * y.shape[-2] - else: - fp16_scale = 65536 * y.shape[-2] - in_scale = fp16_scale**0.5 - x = x.to(dtype=torch.float32).div_(in_scale).to(dtype=torch.float16) - y = y.to(dtype=torch.float32).div_(in_scale).to(dtype=torch.float16) - return torch.mm(x,y).to(dtype=torch.float32).mul_(fp16_scale) - fp_mm_func = fp_mm_torch - - -if os.environ.get("SDNQ_USE_CONTIGUOUS_MM", None) is None: - use_contiguous_int8_mm = bool(use_openvino_mm or is_rdna2_and_older or devices.backend in {"ipex", "mps", "openvino", "zluda"}) - use_contiguous_fp16_mm = bool(use_contiguous_int8_mm or devices.backend == "rocm") -else: - use_contiguous_int8_mm = bool(os.environ.get("SDNQ_USE_CONTIGUOUS_MM", "0").lower() not in {"0", "false", "no"}) - use_contiguous_fp16_mm = use_contiguous_int8_mm - - if use_torch_compile: if hasattr(torch._dynamo.config, "recompile_limit"): torch._dynamo.config.recompile_limit = max(8192, getattr(torch._dynamo.config, "recompile_limit", 0)) diff --git a/modules/sdnq/dequantizer.py b/modules/sdnq/dequantizer.py index 49251b0f8..1344f60a2 100644 --- a/modules/sdnq/dequantizer.py +++ b/modules/sdnq/dequantizer.py @@ -5,13 +5,18 @@ from dataclasses import dataclass import torch from modules import devices -from .common import dtype_dict, compile_func, use_contiguous_int8_mm, use_contiguous_fp16_mm, use_tensorwise_fp8_matmul +from .common import dtype_dict, compile_func +from .kernel_wrappers import use_contiguous_int8_mm, use_contiguous_fp16_mm, use_tensorwise_fp8_matmul, is_fp8_compile_supported from .quant_utils import quantize_int_mm, quantize_uint_mm, quantize_fp_mm, rotate_hadamard, get_hadamard from .packed_int import unpack_int from .packed_float import unpack_float from .layers import SDNQLayer +def skip_fp8_compile(weights_dtype: str) -> bool: # triton has no e4m3 conversions before sm_89, compiled dequant would crash + return not is_fp8_compile_supported and dtype_dict[weights_dtype]["storage_dtype"] == torch.float8_e4m3fn + + @devices.inference_context() def dequantize_asymmetric( weight: torch.Tensor, @@ -118,7 +123,7 @@ def re_quantize_int_mm(weight: torch.FloatTensor, matmul_dtype: str = "int8") -> weight, scale = quantize_int_mm(weight.t().contiguous(), dim=0, matmul_dtype=matmul_dtype) else: weight, scale = quantize_int_mm(weight.contiguous(), dim=-1, matmul_dtype=matmul_dtype) - weight, scale = weight.t_(), scale.t_() + weight, scale = weight.t_(), scale.t_().contiguous() return weight, scale @@ -130,7 +135,7 @@ def re_quantize_uint_mm(weight: torch.FloatTensor, matmul_dtype: str = "uint8") weight, scale, zero_point = quantize_uint_mm(weight.t().contiguous(), dim=0, matmul_dtype=matmul_dtype) else: weight, scale, zero_point = quantize_uint_mm(weight.contiguous(), dim=-1, matmul_dtype=matmul_dtype) - weight, scale, zero_point = weight.t_(), scale.t_(), zero_point.t_() + weight, scale, zero_point = weight.t_(), scale.t_().contiguous(), zero_point.t_().contiguous() return weight, scale, zero_point @@ -142,7 +147,7 @@ def re_quantize_fp_mm(weight: torch.FloatTensor, matmul_dtype: str = "float8_e4m weight, scale = quantize_fp_mm(weight.t().contiguous(), dim=0, matmul_dtype=matmul_dtype) else: weight, scale = quantize_fp_mm(weight.contiguous(), dim=-1, matmul_dtype=matmul_dtype) - weight, scale = weight.t_(), scale.t_() + weight, scale = weight.t_(), scale.t_().contiguous() if not use_tensorwise_fp8_matmul and dtype_dict[matmul_dtype]["num_bits"] == 8: scale = scale.to(dtype=torch.float32) return weight, scale @@ -272,10 +277,14 @@ class SDNQDequantizer: self.use_stochastic_rounding = use_stochastic_rounding self.use_hadamard = use_hadamard self.layer_class_name = layer_class_name + self.num_bits = dtype_dict[weights_dtype]["num_bits"] self.is_packed = dtype_dict[weights_dtype]["is_packed"] - self.is_unsigned = dtype_dict[weights_dtype]["is_unsigned"] self.is_integer = dtype_dict[weights_dtype]["is_integer"] + self.is_unsigned = dtype_dict[weights_dtype]["is_unsigned"] + self.num_bits_matmul = dtype_dict[quantized_matmul_dtype]["num_bits"] + self.is_packed_matmul = dtype_dict[quantized_matmul_dtype]["is_packed"] self.is_integer_matmul = dtype_dict[quantized_matmul_dtype]["is_integer"] + self.is_unsigned_matmul = dtype_dict[quantized_matmul_dtype]["is_unsigned"] @devices.inference_context() def re_quantize_matmul( @@ -287,10 +296,12 @@ class SDNQDequantizer: svd_down: torch.FloatTensor | None = None, hadamard: torch.FloatTensor | None = None, non_hadamard: bool = True, + skip_compile: bool = False, ) -> tuple[torch.Tensor, torch.FloatTensor]: # pylint: disable=unused-argument if hadamard is None and self.use_hadamard and not non_hadamard: hadamard = get_hadamard(self.hadamard_group_size, dtype=self.result_dtype, device=weight.device) - return re_quantize_matmul_compiled( + re_quantize_matmul_func = re_quantize_matmul if skip_compile or skip_fp8_compile(self.weights_dtype) else re_quantize_matmul_compiled + return re_quantize_matmul_func( self.weights_dtype, weight, scale, @@ -322,7 +333,7 @@ class SDNQDequantizer: if hadamard is None and self.use_hadamard and not non_hadamard: hadamard = get_hadamard(self.hadamard_group_size, dtype=dtype, device=weight.device) re_quantize_for_matmul = self.re_quantize_for_matmul or self.is_packed - dequantize_weight_func = dequantize_weight if skip_compile else dequantize_weight_compiled + dequantize_weight_func = dequantize_weight if skip_compile or skip_fp8_compile(self.weights_dtype) else dequantize_weight_compiled return dequantize_weight_func( self.weights_dtype, weight, diff --git a/modules/sdnq/forward.py b/modules/sdnq/forward.py index f66275b74..513be32bb 100644 --- a/modules/sdnq/forward.py +++ b/modules/sdnq/forward.py @@ -2,7 +2,7 @@ from collections.abc import Callable -from .common import dtype_dict, embedding_types, conv_types, conv_transpose_types, use_tensorwise_fp8_matmul +from .common import dtype_dict, embedding_types, conv_types, conv_transpose_types def get_forward_func(layer_class_name: str, quantized_matmul_dtype: str, use_quantized_matmul: bool) -> Callable: # pylint: disable=inconsistent-return-statements @@ -20,12 +20,8 @@ def get_forward_func(layer_class_name: str, quantized_matmul_dtype: str, use_qua return quantized_conv_forward_int8_matmul else: if dtype_dict[quantized_matmul_dtype]["num_bits"] == 8: - if use_tensorwise_fp8_matmul: - from .layers.conv.conv_fp8 import quantized_conv_forward_fp8_matmul - return quantized_conv_forward_fp8_matmul - else: - from .layers.conv.conv_fp8_scaled import quantized_conv_forward_fp8_scaled_matmul - return quantized_conv_forward_fp8_scaled_matmul + from .layers.conv.conv_fp8 import quantized_conv_forward_fp8_matmul + return quantized_conv_forward_fp8_matmul else: from .layers.conv.conv_fp16 import quantized_conv_forward_fp16_matmul return quantized_conv_forward_fp16_matmul @@ -53,12 +49,8 @@ def get_forward_func(layer_class_name: str, quantized_matmul_dtype: str, use_qua return quantized_linear_forward_int8_matmul else: if dtype_dict[quantized_matmul_dtype]["num_bits"] == 8: - if use_tensorwise_fp8_matmul: - from .layers.linear.linear_fp8 import quantized_linear_forward_fp8_matmul - return quantized_linear_forward_fp8_matmul - else: - from .layers.linear.linear_fp8_scaled import quantized_linear_forward_fp8_scaled_matmul - return quantized_linear_forward_fp8_scaled_matmul + from .layers.linear.linear_fp8 import quantized_linear_forward_fp8_matmul + return quantized_linear_forward_fp8_matmul else: from .layers.linear.linear_fp16 import quantized_linear_forward_fp16_matmul return quantized_linear_forward_fp16_matmul diff --git a/modules/sdnq/kernel_wrappers.py b/modules/sdnq/kernel_wrappers.py new file mode 100644 index 000000000..fbdb85f89 --- /dev/null +++ b/modules/sdnq/kernel_wrappers.py @@ -0,0 +1,155 @@ +# pylint: disable=protected-access + +import os +import sys +import torch + +from modules import devices + + +if os.environ.get("SDNQ_ALLOW_FP8_MM", None) is None: + if devices.backend == "cuda": + is_fp8_mm_supported = bool(torch.cuda.get_device_capability(devices.device) >= (8,9)) + elif devices.backend == "rocm": + gfx_version = devices.get_hip_agent().gfx_version + is_fp8_mm_supported = bool(gfx_version >= 0x1200 or (gfx_version >= 0x940 and gfx_version < 0x1000)) + else: + is_fp8_mm_supported = False +else: + is_fp8_mm_supported = os.environ.get("SDNQ_ALLOW_FP8_MM", "0").lower() not in {"0", "false", "no"} + +if os.environ.get("SDNQ_ALLOW_FP8_COMPILE", None) is None: + if devices.backend == "cuda" and "linux" in sys.platform: + is_fp8_compile_supported = bool(torch.cuda.get_device_capability(devices.device) >= (8,9)) # triton has no e4m3 conversions before sm_89 + else: + is_fp8_compile_supported = True +else: + is_fp8_compile_supported = os.environ.get("SDNQ_ALLOW_FP8_COMPILE", "0").lower() not in {"0", "false", "no"} + +if devices.backend == "rocm": + gfx_version = devices.get_hip_agent().gfx_version + is_rdna2_and_older = bool(gfx_version < 0x940 or (gfx_version < 0x1100 and gfx_version >= 0x1000)) +else: + is_rdna2_and_older = False + +if os.environ.get("SDNQ_USE_OPENVINO_MM", None) is None: + use_openvino_mm = bool(devices.backend in {"cpu", "openvino"}) +else: + use_openvino_mm = bool(os.environ.get("SDNQ_USE_OPENVINO_MM", "0").lower() not in {"0", "false", "no"}) + +if os.environ.get("SDNQ_USE_TRITON_MM", None) is None: + use_triton_mm = bool(is_rdna2_and_older or devices.backend in {"zluda", "ipex", "xpu"}) +else: + use_triton_mm = bool(os.environ.get("SDNQ_USE_TRITON_MM", "0").lower() not in {"0", "false", "no"}) + +if os.environ.get("SDNQ_USE_TENSORWISE_FP8_MM", None) is None: + # row-wise FP8 only exist on H100 hardware, sdnq will use software row-wise with tensorwise hardware with this setting + use_tensorwise_fp8_matmul = bool(devices.backend != "cuda" or (devices.backend == "cuda" and torch.cuda.get_device_capability(devices.device) < (9,0))) +else: + use_tensorwise_fp8_matmul = os.environ.get("SDNQ_USE_TENSORWISE_FP8_MM", "0").lower() not in {"0", "false", "no"} + +if os.environ.get("SDNQ_USE_CONTIGUOUS_MM", None) is None: + use_contiguous_int8_mm = bool(use_openvino_mm or is_rdna2_and_older or devices.backend in {"ipex", "xpu", "mps", "openvino", "zluda"}) + use_contiguous_fp16_mm = bool(use_contiguous_int8_mm or devices.backend == "rocm") +else: + use_contiguous_int8_mm = bool(os.environ.get("SDNQ_USE_CONTIGUOUS_MM", "0").lower() not in {"0", "false", "no"}) + use_contiguous_fp16_mm = use_contiguous_int8_mm + + +int_mm_func = None +fp_mm_func = None +fp8_mm_func = None +int_scaled_mm_func = None +fp_scaled_mm_func = None +fp8_scaled_mm_func = None + +if use_openvino_mm: + try: + from .kernels.openvino_mm import openvino_int_mm, openvino_fp_mm + int_mm_func = openvino_int_mm + fp_mm_func = openvino_fp_mm + except Exception: + use_openvino_mm = False +elif use_triton_mm: + try: + from .kernels.triton_mm import sdnq_triton_mm + from .kernels.triton_scaled_mm import sdnq_scaled_mm + int_mm_func = sdnq_triton_mm + fp_mm_func = sdnq_triton_mm + int_scaled_mm_func = sdnq_scaled_mm + fp_scaled_mm_func = sdnq_scaled_mm + if is_fp8_mm_supported: + fp8_mm_func = sdnq_triton_mm + fp8_scaled_mm_func = sdnq_scaled_mm + use_tensorwise_fp8_matmul = False + except Exception: + use_triton_mm = False + +if fp_mm_func is None and os.environ.get("SDNQ_USE_TRITON_MM", "1").lower() not in {"0", "false", "no"}: + try: + from .kernels.triton_mm import sdnq_triton_mm + from .kernels.triton_scaled_mm import sdnq_scaled_mm + fp_mm_func = sdnq_triton_mm + fp_scaled_mm_func = sdnq_scaled_mm + except Exception: + use_triton_mm = False + + +if int_mm_func is None: + def int_mm_torch(a: torch.Tensor, b: torch.Tensor, out_dtype: torch.dtype = torch.int32) -> torch.FloatTensor: + return torch._int_mm(a,b).to(dtype=out_dtype) + int_mm_func = int_mm_torch + +if fp_mm_func is None: + if devices.backend == "cuda": + def fp_mm_torch(a: torch.Tensor, b: torch.Tensor, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: + return torch.mm(a,b, out_dtype=out_dtype) + else: + def fp_mm_torch(a: torch.Tensor, b: torch.Tensor, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: + if b.dtype == torch.float8_e4m3fn: + fp16_scale = 4 * b.shape[-2] + else: + fp16_scale = 65536 * b.shape[-2] + in_scale = fp16_scale**0.5 + a = a.to(dtype=torch.float32).div_(in_scale).to(dtype=torch.float16) + b = b.to(dtype=torch.float32).div_(in_scale).to(dtype=torch.float16) + return torch.mm(a,b).to(dtype=torch.float32).mul_(fp16_scale).to(dtype=out_dtype) + fp_mm_func = fp_mm_torch + +if fp8_mm_func is None: + def fp8_mm_torch(a: torch.Tensor, b: torch.Tensor, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: + dummy_input_scale = torch.ones(1, device=a.device, dtype=torch.float32) + return torch._scaled_mm(a, b, scale_a=dummy_input_scale, scale_b=dummy_input_scale, bias=None, out_dtype=out_dtype) + fp8_mm_func = fp8_mm_torch + + +if int_scaled_mm_func is None: + def int_scaled_mm_torch(a: torch.Tensor, b: torch.Tensor, scale_a: torch.Tensor, scale_b: torch.Tensor, bias: torch.FloatTensor | None = None, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: + if bias is None: + return int_mm_func(a,b).to(dtype=scale_a.dtype).mul_(scale_a).mul_(scale_b).to(dtype=out_dtype) + else: + return torch.addcmul(bias, int_mm_func(a,b).to(dtype=scale_a.dtype).mul_(scale_a), scale_b).to(dtype=out_dtype) + int_scaled_mm_func = int_scaled_mm_torch + +if fp_scaled_mm_func is None: + def fp_scaled_mm_torch(a: torch.Tensor, b: torch.Tensor, scale_a: torch.Tensor, scale_b: torch.Tensor, bias: torch.FloatTensor | None = None, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: + if bias is None: + return fp_mm_func(a,b).to(dtype=scale_a.dtype).mul_(scale_a).mul_(scale_b).to(dtype=out_dtype) + else: + return torch.addcmul(bias, fp_mm_func(a,b).to(dtype=scale_a.dtype).mul_(scale_a), scale_b).to(dtype=out_dtype) + fp_scaled_mm_func = fp_scaled_mm_torch + +if fp8_scaled_mm_func is None: + if use_tensorwise_fp8_matmul: + def fp8_scaled_mm_torch(a: torch.Tensor, b: torch.Tensor, scale_a: torch.Tensor, scale_b: torch.Tensor, bias: torch.FloatTensor | None = None, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: + if bias is None: + return fp8_mm_func(a,b, out_dtype=scale_a.dtype).mul_(scale_a).mul_(scale_b).to(dtype=out_dtype) + else: + return torch.addcmul(bias, fp8_mm_func(a,b, out_dtype=scale_a.dtype).mul_(scale_a), scale_b).to(dtype=out_dtype) + else: + def fp8_scaled_mm_torch(a: torch.Tensor, b: torch.Tensor, scale_a: torch.Tensor, scale_b: torch.Tensor, bias: torch.FloatTensor | None = None, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: + if bias is not None and bias.ndim != 1: + return torch._scaled_mm(a, b, scale_a=scale_a, scale_b=scale_b, bias=None, out_dtype=out_dtype).add_(bias) + else: + return torch._scaled_mm(a, b, scale_a=scale_a, scale_b=scale_b, bias=bias.to(dtype=out_dtype) if bias is not None else None, out_dtype=out_dtype) + fp8_scaled_mm_func = fp8_scaled_mm_torch diff --git a/modules/sdnq/kernels/openvino_mm.py b/modules/sdnq/kernels/openvino_mm.py index a6cf9255e..3e850810c 100644 --- a/modules/sdnq/kernels/openvino_mm.py +++ b/modules/sdnq/kernels/openvino_mm.py @@ -15,25 +15,25 @@ for ov_device in core.get_available_devices(): core.set_property(ov_device, {ov_hints.execution_mode: ov_hints.ExecutionMode.ACCURACY}) -def ov_mm(A: torch.Tensor, B: torch.Tensor, infer_request: ov.InferRequest, out_name: str) -> torch.FloatTensor: +def ov_mm(A: torch.Tensor, B: torch.Tensor, infer_request: ov.InferRequest, out_name: str, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: C = torch.empty((A.shape[0], B.shape[-1]), device="cpu", dtype=torch.float32) infer_request.set_tensor("A", ov.Tensor(A.detach().contiguous().to("cpu").numpy(), shared_memory=True)) infer_request.set_tensor("B", ov.Tensor(B.detach().contiguous().to("cpu").numpy(), shared_memory=True)) infer_request.set_tensor(out_name, ov.Tensor(C.numpy(), shared_memory=True)) infer_request.infer() - C = C.to(A.device) + C = C.to(A.device, dtype=out_dtype) return C @torch.library.custom_op("sdnq::openvino_int_mm", mutates_args=()) -def openvino_int_mm(Tensor_A: torch.Tensor, Tensor_B: torch.Tensor) -> torch.Tensor: +def openvino_int_mm(Tensor_A: torch.Tensor, Tensor_B: torch.Tensor, out_dtype: torch.dtype = torch.float32) -> torch.Tensor: if "GPU" not in OV_DEVICE: cache_key = (OV_DEVICE, "int8", Tensor_A.shape, Tensor_B.shape) else: cache_key = (OV_DEVICE, "int8", None, None) infer_request, out_name = OV_COMPILED_CACHE.get(cache_key, (None, None)) if infer_request is not None: - return ov_mm(Tensor_A, Tensor_B, infer_request, out_name) + return ov_mm(Tensor_A, Tensor_B, infer_request, out_name, out_dtype=out_dtype) if "GPU" not in OV_DEVICE: shape_a = ov.Shape(Tensor_A.shape) @@ -75,15 +75,15 @@ def openvino_int_mm(Tensor_A: torch.Tensor, Tensor_B: torch.Tensor) -> torch.Ten out_name = ov_model.outputs[0] OV_COMPILED_CACHE[cache_key] = (infer_request, out_name) - return ov_mm(Tensor_A, Tensor_B, infer_request, out_name) + return ov_mm(Tensor_A, Tensor_B, infer_request, out_name, out_dtype=out_dtype) @openvino_int_mm.register_fake -def openvino_int_mm_fake(A: torch.Tensor, B: torch.Tensor) -> torch.Tensor: - return torch.mm(A.to(dtype=torch.float32), B.to(dtype=torch.float32)) +def openvino_int_mm_fake(A: torch.Tensor, B: torch.Tensor, out_dtype: torch.dtype = torch.float32) -> torch.Tensor: + return torch.mm(A.to(dtype=torch.float32), B.to(dtype=torch.float32)).to(dtype=out_dtype) @torch.library.custom_op("sdnq::openvino_fp_mm", mutates_args=()) -def openvino_fp_mm(Tensor_A: torch.Tensor, Tensor_B: torch.Tensor) -> torch.Tensor: +def openvino_fp_mm(Tensor_A: torch.Tensor, Tensor_B: torch.Tensor, out_dtype: torch.dtype = torch.float32) -> torch.Tensor: mm_dtype = "fp16" if Tensor_B.dtype == torch.float16 else "fp8" if mm_dtype == "fp8": Tensor_A = Tensor_A.to(dtype=torch.float16) @@ -94,7 +94,7 @@ def openvino_fp_mm(Tensor_A: torch.Tensor, Tensor_B: torch.Tensor) -> torch.Tens cache_key = (OV_DEVICE, mm_dtype, None, None) infer_request, out_name = OV_COMPILED_CACHE.get(cache_key, (None, None)) if infer_request is not None: - return ov_mm(Tensor_A, Tensor_B, infer_request, out_name) + return ov_mm(Tensor_A, Tensor_B, infer_request, out_name, out_dtype=out_dtype) if "GPU" not in OV_DEVICE: shape_a = ov.Shape(Tensor_A.shape) @@ -135,8 +135,8 @@ def openvino_fp_mm(Tensor_A: torch.Tensor, Tensor_B: torch.Tensor) -> torch.Tens out_name = ov_model.outputs[0] OV_COMPILED_CACHE[cache_key] = (infer_request, out_name) - return ov_mm(Tensor_A, Tensor_B, infer_request, out_name) + return ov_mm(Tensor_A, Tensor_B, infer_request, out_name, out_dtype=out_dtype) @openvino_fp_mm.register_fake -def openvino_fp_mm_fake(A: torch.Tensor, B: torch.Tensor) -> torch.Tensor: - return torch.mm(A.to(dtype=torch.float32), B.to(dtype=torch.float32)) +def openvino_fp_mm_fake(A: torch.Tensor, B: torch.Tensor, out_dtype: torch.dtype = torch.float32) -> torch.Tensor: + return torch.mm(A.to(dtype=torch.float32), B.to(dtype=torch.float32)).to(dtype=out_dtype) diff --git a/modules/sdnq/kernels/triton_atten.py b/modules/sdnq/kernels/triton_atten.py index 93afee23f..5fd7d9fd6 100644 --- a/modules/sdnq/kernels/triton_atten.py +++ b/modules/sdnq/kernels/triton_atten.py @@ -5,7 +5,8 @@ import triton import triton.language as tl from ..common import compile_func # pylint: disable=relative-beyond-top-level -from ..quant_utils import quantize_int_mm, quantize_fp_mm, get_hadamard, apply_hadamard # pylint: disable=relative-beyond-top-level +from ..quant_utils import quantize_int_mm, quantize_fp_mm, get_hadamard, get_hadamard_group_size, apply_hadamard # pylint: disable=relative-beyond-top-level +from ..utils import is_pow2, next_power_of_2 # pylint: disable=relative-beyond-top-level min_block_size = int(os.environ.get("SDNQ_TRITON_ATTEN_MIN_BLOCK_SIZE", "256")) @@ -173,15 +174,15 @@ def sdnq_attn_kernel( p_scale = tl.max(p, 1)[:, None] * (1 / 127.0) p_scale = tl.where(p_scale <= 2e-38, 1.0, p_scale) p = tl.floor(p * (1 / p_scale) + 0.5).to(tl.int8) - acc += tl.dot(p, v, out_dtype=tl.int32).to(tl.float32) * p_scale + acc = tl.fma(tl.dot(p, v, out_dtype=tl.int32).to(tl.float32), p_scale, acc) else: p_scale = tl.max(p, 1)[:, None] * (1 / (65504.0 if v.dtype == tl.float16 else 448.0)) p_scale = tl.where(p_scale <= 2e-38, 1.0, p_scale) p = (p * (1 / p_scale)).to(v.dtype) - acc += tl.dot(p, v, out_dtype=tl.float32) * p_scale + acc = tl.fma(tl.dot(p, v, out_dtype=tl.float32), p_scale, acc) else: p = p.to(v.dtype) - acc += tl.dot(p, v, out_dtype=tl.float32) + acc = tl.dot(p, v, acc, out_dtype=tl.float32) m_i = m_ij l_i = 1 / l_i[:, None] @@ -261,15 +262,15 @@ def get_attn_inputs( out_dtype = query.dtype if scale is None: scale = QHD ** -0.5 - if not math.log(QHD, 2).is_integer(): - query = torch.nn.functional.pad(query, (0, triton.next_power_of_2(QHD) - QHD)) - key = torch.nn.functional.pad(key, (0, triton.next_power_of_2(KHD) - KHD)) - value = torch.nn.functional.pad(value, (0, triton.next_power_of_2(VHD) - VHD)) + if not is_pow2(QHD): + query = torch.nn.functional.pad(query, (0, next_power_of_2(QHD) - QHD)) + key = torch.nn.functional.pad(key, (0, next_power_of_2(KHD) - KHD)) + value = torch.nn.functional.pad(value, (0, next_power_of_2(VHD) - VHD)) if attn_mask is not None: attn_mask = attn_mask.expand((QZ, QH, QN, KN)) - if not math.log(KN, 2).is_integer(): + if not is_pow2(KN): pad_value = float("-inf") if torch.is_floating_point(attn_mask) else 0 - attn_mask = torch.nn.functional.pad(attn_mask, (0, triton.next_power_of_2(KN) - KN), value=pad_value) + attn_mask = torch.nn.functional.pad(attn_mask, (0, next_power_of_2(KN) - KN), value=pad_value) if attn_mask.dtype == torch.bool: attn_mask = attn_mask.to(dtype=torch.int8) attn_mask = attn_mask.contiguous() @@ -302,14 +303,18 @@ def sdnq_triton_atten( do_quantize: bool = True, out_dtype: torch.dtype | None = None, ) -> torch.FloatTensor: - QZ, QH, QN, _ = query.shape - _, _, KN, _ = key.shape + QZ, QH, QN, QHD = query.shape + _, _, KN, KHD = key.shape _, _, VN, VHD = value.shape - if use_hadamard and matmul_dtype not in {None, "none", "no"}: - hadamard = get_hadamard(min(hadamard_group_size, query.shape[-1], key.shape[-1]), dtype=query.dtype, device=query.device) - else: - hadamard = None + hadamard = None + if use_hadamard and do_quantize and matmul_dtype not in {None, "none", "no"}: + hadamard_channel_size = next_power_of_2(min(QHD, KHD)) + hadamard_group_size = min(hadamard_group_size, hadamard_channel_size) + use_hadamard, hadamard_group_size = get_hadamard_group_size(hadamard_channel_size, hadamard_group_size) + if use_hadamard: + hadamard = get_hadamard(hadamard_group_size, dtype=query.dtype, device=query.device) + ( query, query_scale, key, key_scale, @@ -324,6 +329,7 @@ def sdnq_triton_atten( matmul_dtype=matmul_dtype, pv_matmul_dtype=pv_matmul_dtype, do_quantize=do_quantize, out_dtype=out_dtype, ) + def grid(META): return (triton.cdiv(QN, META["BLOCK_SIZE_M"]), QH, QZ) out = torch.empty((QZ, QH, QN, value.shape[-1]), dtype=out_dtype, device=query.device) @@ -346,4 +352,4 @@ def sdnq_triton_atten( return out[..., :VHD] -get_attn_inputs = compile_func(get_attn_inputs, dynamic=True) +get_attn_inputs = compile_func(get_attn_inputs) diff --git a/modules/sdnq/kernels/triton_mm.py b/modules/sdnq/kernels/triton_mm.py index 839d54a00..ac35a410c 100644 --- a/modules/sdnq/kernels/triton_mm.py +++ b/modules/sdnq/kernels/triton_mm.py @@ -1,12 +1,3 @@ -""" -Modified from Triton MatMul example. -PyTorch torch._int_mm is broken on backward pass with Nvidia, so we use Triton on the backward pass with Nvidia. -AMD RDNA2 doesn't support torch._int_mm as it requires INT8 WMMA, so we use INT8 DP4A via Triton. -PyTorch doesn't support FP32 output type with FP16 MM, so we use Triton for FP16 MM too. -matmul_configs we use takes AMD and Intel into consideration too. -SDNQ Triton configs can outperform RocBLAS and OneDNN. -""" - import os import math import torch @@ -18,92 +9,24 @@ import triton.language as tl min_block_size = int(os.environ.get("SDNQ_TRITON_MM_MIN_BLOCK_SIZE", "256")) matmul_configs = [ triton.Config({"BLOCK_SIZE_M": BM, "BLOCK_SIZE_N": BN, "BLOCK_SIZE_K": BK, "GROUP_SIZE_M": GM}, num_warps=w, num_stages=s) - for BM in [int(BM) for BM in os.environ.get("SDNQ_TRITON_MM_BLOCK_SIZE_M_LIST", "64").replace(" ","").split(",")] + for BM in [int(BM) for BM in os.environ.get("SDNQ_TRITON_MM_BLOCK_SIZE_M_LIST", "64,128").replace(" ","").split(",")] for BN in [int(BN) for BN in os.environ.get("SDNQ_TRITON_MM_BLOCK_SIZE_N_LIST", "64,128,256").replace(" ","").split(",")] - for BK in [int(BK) for BK in os.environ.get("SDNQ_TRITON_MM_BLOCK_SIZE_K_LIST", "32,64").replace(" ","").split(",")] - for GM in [int(GM) for GM in os.environ.get("SDNQ_TRITON_MM_GROUP_SIZE_M_LIST", "2,4,8").replace(" ","").split(",")] - for w in [int(w) for w in os.environ.get("SDNQ_TRITON_MM_NUM_WARPS_LIST", "4,8").replace(" ","").split(",")] + for BK in [int(BK) for BK in os.environ.get("SDNQ_TRITON_MM_BLOCK_SIZE_K_LIST", "32,64,128").replace(" ","").split(",")] + for GM in [int(GM) for GM in os.environ.get("SDNQ_TRITON_MM_GROUP_SIZE_M_LIST", "8").replace(" ","").split(",")] + for w in [int(w) for w in os.environ.get("SDNQ_TRITON_MM_NUM_WARPS_LIST", "16" if torch.xpu.is_available() else "4").replace(" ","").split(",")] for s in [int(s) for s in os.environ.get("SDNQ_TRITON_MM_NUM_STAGES_LIST", "2").replace(" ","").split(",")] ] -@triton.autotune(configs=matmul_configs, key=["M_AT", "N_AT", "K_AT", "a_dtype", "out_dtype"], cache_results=True) +@triton.autotune(configs=matmul_configs, key=["b_is_contiguous", "bias_ndim", "M_AT", "N_AT", "K_AT", "a_dtype", "out_dtype"], cache_results=True) @triton.jit -def triton_mm_kernel( - a_ptr, b_ptr, c_ptr, - M: tl.constexpr, - N: tl.constexpr, - K: tl.constexpr, - M_AT: tl.constexpr, # pylint: disable=unused-argument - N_AT: tl.constexpr, # pylint: disable=unused-argument - K_AT: tl.constexpr, # pylint: disable=unused-argument - stride_am: tl.constexpr, stride_ak: tl.constexpr, - stride_bk: tl.constexpr, stride_bn: tl.constexpr, - stride_cm: tl.constexpr, stride_cn: tl.constexpr, - a_dtype: tl.constexpr, # pylint: disable=unused-argument - out_dtype: tl.constexpr, # pylint: disable=unused-argument - BLOCK_SIZE_M: tl.constexpr, - BLOCK_SIZE_N: tl.constexpr, - BLOCK_SIZE_K: tl.constexpr, - GROUP_SIZE_M: tl.constexpr, -) -> None: - pid = tl.program_id(axis=0) - num_pid_m: tl.constexpr = tl.cdiv(M, BLOCK_SIZE_M) - num_pid_n: tl.constexpr = tl.cdiv(N, BLOCK_SIZE_N) - num_pid_in_group: tl.constexpr = GROUP_SIZE_M * num_pid_n - group_id = pid // num_pid_in_group - first_pid_m = group_id * GROUP_SIZE_M - group_size_m = min(num_pid_m - first_pid_m, GROUP_SIZE_M) - pid_m = first_pid_m + ((pid % num_pid_in_group) % group_size_m) - pid_n = (pid % num_pid_in_group) // group_size_m - - tl.assume(M > 0) - tl.assume(N > 0) - tl.assume(K > 0) - tl.assume(pid_m >= 0) - tl.assume(pid_n >= 0) - tl.assume(stride_am > 0) - tl.assume(stride_ak > 0) - tl.assume(stride_bn > 0) - tl.assume(stride_bk > 0) - tl.assume(stride_cm > 0) - tl.assume(stride_cn > 0) - tl.assume(BLOCK_SIZE_M > 0) - tl.assume(BLOCK_SIZE_N > 0) - tl.assume(BLOCK_SIZE_K > 0) - tl.assume(GROUP_SIZE_M > 0) - - offs_am = (pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)) % M - offs_bn = (pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)) % N - offs_k = tl.arange(0, BLOCK_SIZE_K) - a_ptrs = a_ptr + (offs_am[:, None] * stride_am + offs_k[None, :] * stride_ak) - b_ptrs = b_ptr + (offs_k[:, None] * stride_bk + offs_bn[None, :] * stride_bn) - - accumulator_dtype = tl.int32 if a_ptr.type.element_ty == tl.int8 else tl.float32 - accumulator = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=accumulator_dtype) - for k in tl.range(0, tl.cdiv(K, BLOCK_SIZE_K)): - a = tl.load(a_ptrs, mask=offs_k[None, :] < K - k * BLOCK_SIZE_K, other=0.0) - b = tl.load(b_ptrs, mask=offs_k[:, None] < K - k * BLOCK_SIZE_K, other=0.0) - accumulator = tl.dot(a, b, accumulator, out_dtype=accumulator_dtype) - a_ptrs += BLOCK_SIZE_K * stride_ak - b_ptrs += BLOCK_SIZE_K * stride_bk - - accumulator = accumulator.to(c_ptr.type.element_ty) - offs_cm = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M) - offs_cn = pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N) - c_ptrs = c_ptr + stride_cm * offs_cm[:, None] + stride_cn * offs_cn[None, :] - c_mask = (offs_cm[:, None] < M) & (offs_cn[None, :] < N) - tl.store(c_ptrs, accumulator, mask=c_mask) - - -# Intel requires tensor descriptors to perform good -@triton.autotune(configs=matmul_configs, key=["M_AT", "N_AT", "K_AT", "a_dtype", "out_dtype"], cache_results=True) -@triton.jit -def triton_mm_td_kernel( - a_ptr, b_ptr, c_ptr, +def sdnq_triton_mm_kernel( + a_ptr, b_ptr, c_ptr, bias_ptr, M: tl.constexpr, N: tl.constexpr, K: tl.constexpr, + b_is_contiguous: tl.constexpr, + bias_ndim: tl.constexpr, M_AT: tl.constexpr, # pylint: disable=unused-argument N_AT: tl.constexpr, # pylint: disable=unused-argument K_AT: tl.constexpr, # pylint: disable=unused-argument @@ -123,93 +46,86 @@ def triton_mm_td_kernel( group_size_m = min(num_pid_m - first_pid_m, GROUP_SIZE_M) pid_m = first_pid_m + ((pid % num_pid_in_group) % group_size_m) pid_n = (pid % num_pid_in_group) // group_size_m + off_m = pid_m * BLOCK_SIZE_M + off_n = pid_n * BLOCK_SIZE_N tl.assume(M > 0) tl.assume(N > 0) tl.assume(K > 0) tl.assume(pid_m >= 0) tl.assume(pid_n >= 0) + tl.assume(off_m >= 0) + tl.assume(off_n >= 0) tl.assume(BLOCK_SIZE_M > 0) tl.assume(BLOCK_SIZE_N > 0) tl.assume(BLOCK_SIZE_K > 0) tl.assume(GROUP_SIZE_M > 0) + tl.assume(b_is_contiguous == 0 or b_is_contiguous == 1) # pylint: disable=consider-using-in + tl.assume(bias_ndim >= 0 and bias_ndim <= 2) # pylint: disable=consider-using-in a_desc = tl.make_tensor_descriptor(base=a_ptr, shape=(M, K), strides=(K, 1), block_shape=(BLOCK_SIZE_M, BLOCK_SIZE_K)) - b_desc = tl.make_tensor_descriptor(base=b_ptr, shape=(K, N), strides=(N, 1), block_shape=(BLOCK_SIZE_K, BLOCK_SIZE_N)) + if b_is_contiguous: + b_desc = tl.make_tensor_descriptor(base=b_ptr, shape=(K, N), strides=(N, 1), block_shape=(BLOCK_SIZE_K, BLOCK_SIZE_N)) + else: + offs_k = tl.arange(0, BLOCK_SIZE_K) + offs_bn = (off_n + tl.arange(0, BLOCK_SIZE_N)) % N + b_ptrs = b_ptr + (offs_k[:, None] + offs_bn[None, :] * K) off_k = 0 - accumulator_dtype = tl.int32 if a_ptr.type.element_ty == tl.int8 else tl.float32 + accumulator_dtype: tl.constexpr = tl.int32 if a_ptr.type.element_ty == tl.int8 else tl.float32 accumulator = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=accumulator_dtype) for _ in tl.range(0, tl.cdiv(K, BLOCK_SIZE_K)): - a = a_desc.load([pid_m * BLOCK_SIZE_M, off_k]) - b = b_desc.load([off_k, pid_n * BLOCK_SIZE_N]) + a = a_desc.load([off_m, off_k]) + if b_is_contiguous: + b = b_desc.load([off_k, off_n]) + else: + b = tl.load(b_ptrs, mask=offs_k[:, None] < K - off_k, other=0.0) + b_ptrs += BLOCK_SIZE_K accumulator = tl.dot(a, b, accumulator, out_dtype=accumulator_dtype) off_k += BLOCK_SIZE_K + if bias_ndim == 1: + accumulator = accumulator.to(tl.float32) + bias_desc = tl.make_tensor_descriptor(base=bias_ptr, shape=(N,), strides=(1,), block_shape=(BLOCK_SIZE_N,)) + bias = bias_desc.load([off_n])[None, :].to(tl.float32) + accumulator += bias + elif bias_ndim == 2: + accumulator = accumulator.to(tl.float32) + bias_desc = tl.make_tensor_descriptor(base=bias_ptr, shape=(M, N), strides=(N, 1), block_shape=(BLOCK_SIZE_M, BLOCK_SIZE_N)) + bias = bias_desc.load([off_m, off_n]).to(tl.float32) + accumulator += bias + accumulator = accumulator.to(c_ptr.type.element_ty) c_desc = tl.make_tensor_descriptor(base=c_ptr, shape=(M, N), strides=(N, 1), block_shape=(BLOCK_SIZE_M, BLOCK_SIZE_N)) - c_desc.store([pid_m * BLOCK_SIZE_M, pid_n * BLOCK_SIZE_N], accumulator) + c_desc.store([off_m, off_n], accumulator) -def triton_int_mm(a: torch.Tensor, b: torch.Tensor, out_dtype: torch.dtype = torch.int32) -> torch.Tensor: +def sdnq_triton_mm( + a: torch.Tensor, + b: torch.Tensor, + bias: torch.FloatTensor | None = None, + out_dtype: torch.dtype | None = None, +) -> torch.Tensor: assert a.shape[1] == b.shape[0], "Incompatible dimensions" assert a.is_contiguous(), "Matrix A must be contiguous" + if bias is not None: + assert bias.is_contiguous(), "Bias must be contiguous" + assert bias.ndim in {1, 2}, "Bias must be 1D or 2D" M, K = a.shape K, N = b.shape + if out_dtype is None: + out_dtype = torch.int32 if a.dtype == torch.int8 else torch.float32 c = torch.empty((M, N), device=a.device, dtype=out_dtype) def grid(META): return (triton.cdiv(M, META["BLOCK_SIZE_M"]) * triton.cdiv(N, META["BLOCK_SIZE_N"]), ) - if b.is_contiguous(): - triton_mm_td_kernel[grid]( - a, b, c, - M, N, K, - math.ceil(M / min_block_size), - math.ceil(N / min_block_size), - math.ceil(K / min_block_size), - str(a.dtype), str(c.dtype), - ) - else: - triton_mm_kernel[grid]( - a, b, c, - M, N, K, - math.ceil(M / min_block_size), - math.ceil(N / min_block_size), - math.ceil(K / min_block_size), - a.stride(0), a.stride(1), - b.stride(0), b.stride(1), - c.stride(0), c.stride(1), - str(a.dtype), str(c.dtype), - ) - return c - - -def triton_fp_mm(a: torch.FloatTensor, b: torch.FloatTensor, out_dtype: torch.dtype = torch.float32) -> torch.FloatTensor: - assert a.shape[1] == b.shape[0], "Incompatible dimensions" - assert a.is_contiguous(), "Matrix A must be contiguous" - M, K = a.shape - K, N = b.shape - c = torch.empty((M, N), device=a.device, dtype=out_dtype) - def grid(META): - return (triton.cdiv(M, META["BLOCK_SIZE_M"]) * triton.cdiv(N, META["BLOCK_SIZE_N"]), ) - if b.is_contiguous(): - triton_mm_td_kernel[grid]( - a, b, c, - M, N, K, - math.ceil(M / min_block_size), - math.ceil(N / min_block_size), - math.ceil(K / min_block_size), - str(a.dtype), str(c.dtype), - ) - else: - triton_mm_kernel[grid]( - a, b, c, - M, N, K, - math.ceil(M / min_block_size), - math.ceil(N / min_block_size), - math.ceil(K / min_block_size), - a.stride(0), a.stride(1), - b.stride(0), b.stride(1), - c.stride(0), c.stride(1), - str(a.dtype), str(c.dtype), - ) + sdnq_triton_mm_kernel[grid]( + a, b, c, bias, + M, N, K, + (1 if b.is_contiguous() else 0), + (0 if bias is None else bias.ndim), + math.ceil(M / min_block_size), + math.ceil(N / min_block_size), + math.ceil(K / min_block_size), + str(a.dtype), str(c.dtype), + ) return c diff --git a/modules/sdnq/kernels/triton_scaled_mm.py b/modules/sdnq/kernels/triton_scaled_mm.py new file mode 100644 index 000000000..18779e74d --- /dev/null +++ b/modules/sdnq/kernels/triton_scaled_mm.py @@ -0,0 +1,147 @@ +""" +W4A8 fallback with Triton. +This is intended as a template for future INT4 MM kernels as Triton has no support for INT4 hardware yet. +""" + +import os +import math +import torch + +import triton +import triton.language as tl + + +min_block_size = int(os.environ.get("SDNQ_TRITON_MM_MIN_BLOCK_SIZE", "256")) +matmul_configs = [ + triton.Config({"BLOCK_SIZE_M": BM, "BLOCK_SIZE_N": BN, "BLOCK_SIZE_K": BK, "GROUP_SIZE_M": GM}, num_warps=w, num_stages=s) + for BM in [int(BM) for BM in os.environ.get("SDNQ_TRITON_MM_BLOCK_SIZE_M_LIST", "64,128").replace(" ","").split(",")] + for BN in [int(BN) for BN in os.environ.get("SDNQ_TRITON_MM_BLOCK_SIZE_N_LIST", "64,128,256").replace(" ","").split(",")] + for BK in [int(BK) for BK in os.environ.get("SDNQ_TRITON_MM_BLOCK_SIZE_K_LIST", "32,64,128").replace(" ","").split(",")] + for GM in [int(GM) for GM in os.environ.get("SDNQ_TRITON_MM_GROUP_SIZE_M_LIST", "8").replace(" ","").split(",")] + for w in [int(w) for w in os.environ.get("SDNQ_TRITON_MM_NUM_WARPS_LIST", "16" if torch.xpu.is_available() else "4").replace(" ","").split(",")] + for s in [int(s) for s in os.environ.get("SDNQ_TRITON_MM_NUM_STAGES_LIST", "2").replace(" ","").split(",")] +] + + +@triton.autotune(configs=matmul_configs, key=["b_is_contiguous", "bias_ndim", "M_AT", "N_AT", "K_AT", "a_dtype", "out_dtype"], cache_results=True) +@triton.jit +def sdnq_scaled_mm_kernel( + a_ptr, b_ptr, c_ptr, bias_ptr, + scale_a_ptr, scale_b_ptr, + M: tl.constexpr, + N: tl.constexpr, + K: tl.constexpr, + b_is_contiguous: tl.constexpr, + bias_ndim: tl.constexpr, + M_AT: tl.constexpr, # pylint: disable=unused-argument + N_AT: tl.constexpr, # pylint: disable=unused-argument + K_AT: tl.constexpr, # pylint: disable=unused-argument + a_dtype: tl.constexpr, # pylint: disable=unused-argument + out_dtype: tl.constexpr, # pylint: disable=unused-argument + BLOCK_SIZE_M: tl.constexpr, + BLOCK_SIZE_N: tl.constexpr, + BLOCK_SIZE_K: tl.constexpr, + GROUP_SIZE_M: tl.constexpr, +) -> None: + pid = tl.program_id(axis=0) + num_pid_m: tl.constexpr = tl.cdiv(M, BLOCK_SIZE_M) + num_pid_n: tl.constexpr = tl.cdiv(N, BLOCK_SIZE_N) + num_pid_in_group: tl.constexpr = GROUP_SIZE_M * num_pid_n + group_id = pid // num_pid_in_group + first_pid_m = group_id * GROUP_SIZE_M + group_size_m = min(num_pid_m - first_pid_m, GROUP_SIZE_M) + pid_m = first_pid_m + ((pid % num_pid_in_group) % group_size_m) + pid_n = (pid % num_pid_in_group) // group_size_m + off_m = pid_m * BLOCK_SIZE_M + off_n = pid_n * BLOCK_SIZE_N + + tl.assume(M > 0) + tl.assume(N > 0) + tl.assume(K > 0) + tl.assume(pid_m >= 0) + tl.assume(pid_n >= 0) + tl.assume(off_m >= 0) + tl.assume(off_n >= 0) + tl.assume(BLOCK_SIZE_M > 0) + tl.assume(BLOCK_SIZE_N > 0) + tl.assume(BLOCK_SIZE_K > 0) + tl.assume(GROUP_SIZE_M > 0) + tl.assume(b_is_contiguous == 0 or b_is_contiguous == 1) # pylint: disable=consider-using-in + tl.assume(bias_ndim >= 0 and bias_ndim <= 2) # pylint: disable=consider-using-in + + a_desc = tl.make_tensor_descriptor(base=a_ptr, shape=(M, K), strides=(K, 1), block_shape=(BLOCK_SIZE_M, BLOCK_SIZE_K)) + if b_is_contiguous: + b_desc = tl.make_tensor_descriptor(base=b_ptr, shape=(K, N), strides=(N, 1), block_shape=(BLOCK_SIZE_K, BLOCK_SIZE_N)) + else: + offs_k = tl.arange(0, BLOCK_SIZE_K) + offs_bn = (off_n + tl.arange(0, BLOCK_SIZE_N)) % N + b_ptrs = b_ptr + (offs_k[:, None] + offs_bn[None, :] * K) + + off_k = 0 + accumulator_dtype: tl.constexpr = tl.int32 if a_ptr.type.element_ty == tl.int8 else tl.float32 + accumulator = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=accumulator_dtype) + for _ in tl.range(0, tl.cdiv(K, BLOCK_SIZE_K)): + a = a_desc.load([off_m, off_k]) + if b_is_contiguous: + b = b_desc.load([off_k, off_n]) + else: + b = tl.load(b_ptrs, mask=offs_k[:, None] < K - off_k, other=0.0) + b_ptrs += BLOCK_SIZE_K + accumulator = tl.dot(a, b, accumulator, out_dtype=accumulator_dtype) + off_k += BLOCK_SIZE_K + + scale_a_desc = tl.make_tensor_descriptor(base=scale_a_ptr, shape=(M,), strides=(1,), block_shape=(BLOCK_SIZE_M,)) + scale_b_desc = tl.make_tensor_descriptor(base=scale_b_ptr, shape=(N,), strides=(1,), block_shape=(BLOCK_SIZE_N,)) + scale_a = scale_a_desc.load([off_m])[:, None].to(tl.float32) + scale_b = scale_b_desc.load([off_n])[None, :].to(tl.float32) + + if bias_ndim == 1: + accumulator = accumulator.to(tl.float32) * scale_a + bias_desc = tl.make_tensor_descriptor(base=bias_ptr, shape=(N,), strides=(1,), block_shape=(BLOCK_SIZE_N,)) + bias = bias_desc.load([off_n])[None, :].to(tl.float32) + accumulator = tl.fma(accumulator, scale_b, bias) + elif bias_ndim == 2: + accumulator = accumulator.to(tl.float32) * scale_a + bias_desc = tl.make_tensor_descriptor(base=bias_ptr, shape=(M, N), strides=(N, 1), block_shape=(BLOCK_SIZE_M, BLOCK_SIZE_N)) + bias = bias_desc.load([off_m, off_n]).to(tl.float32) + accumulator = tl.fma(accumulator, scale_b, bias) + else: + accumulator = accumulator.to(tl.float32) * scale_a * scale_b + + accumulator = accumulator.to(c_ptr.type.element_ty) + c_desc = tl.make_tensor_descriptor(base=c_ptr, shape=(M, N), strides=(N, 1), block_shape=(BLOCK_SIZE_M, BLOCK_SIZE_N)) + c_desc.store([off_m, off_n], accumulator) + + +def sdnq_scaled_mm( + a: torch.Tensor, + b: torch.Tensor, + scale_a: torch.Tensor, + scale_b: torch.Tensor, + bias: torch.FloatTensor | None = None, + out_dtype: torch.dtype = torch.float32, +) -> torch.Tensor: + assert a.shape[1] == b.shape[0], "Incompatible dimensions" + assert a.is_contiguous(), "Matrix A must be contiguous" + assert scale_a.is_contiguous(), "Matrix A scale must be contiguous" + assert scale_b.is_contiguous(), "Matrix B scale must be contiguous" + if bias is not None: + assert bias.is_contiguous(), "Bias must be contiguous" + assert bias.ndim in {1, 2}, "Bias must be 1D or 2D" + M, K = a.shape + K, N = b.shape + c = torch.empty((M, N), device=a.device, dtype=out_dtype) + def grid(META): + return (triton.cdiv(M, META["BLOCK_SIZE_M"]) * triton.cdiv(N, META["BLOCK_SIZE_N"]), ) + sdnq_scaled_mm_kernel[grid]( + a, b, c, bias, + scale_a, scale_b, + M, N, K, + (1 if b.is_contiguous() else 0), + (0 if bias is None else bias.ndim), + math.ceil(M / min_block_size), + math.ceil(N / min_block_size), + math.ceil(K / min_block_size), + str(a.dtype), str(c.dtype), + ) + return c diff --git a/modules/sdnq/layers/conv/conv_fp16.py b/modules/sdnq/layers/conv/conv_fp16.py index 83783e63b..19a0d57bb 100644 --- a/modules/sdnq/layers/conv/conv_fp16.py +++ b/modules/sdnq/layers/conv/conv_fp16.py @@ -2,7 +2,8 @@ import torch -from ...common import compile_func, fp_mm_func +from ...common import compile_func +from ...kernel_wrappers import fp_mm_func, fp_scaled_mm_func from ...dequantizer import dequantize_symmetric, dequantize_asymmetric from ...quant_utils import rotate_hadamard, get_hadamard from ...packed_float import unpack_float @@ -50,7 +51,7 @@ def conv_fp16_matmul( input, weight = check_mats(input, weight) if groups == 1: - result = fp_mm_func(input, weight).to(dtype=input_scale.dtype).mul_(input_scale) + result = fp_scaled_mm_func(input, weight, input_scale, scale, bias=bias, out_dtype=return_dtype).view(mm_output_shape) else: weight = weight.view(weight.shape[0], groups, weight.shape[1] // groups) input = input.view(input.shape[0], groups, input.shape[1] // groups) @@ -58,10 +59,10 @@ def conv_fp16_matmul( for i in range(groups): result.append(fp_mm_func(input[:, i], weight[:, i])) result = torch.cat(result, dim=-1).to(dtype=input_scale.dtype).mul_(input_scale) - if bias is not None: - dequantize_asymmetric(result, scale, bias, dtype=return_dtype, result_shape=mm_output_shape) - else: - dequantize_symmetric(result, scale, dtype=return_dtype, result_shape=mm_output_shape) + if bias is not None: + result = dequantize_asymmetric(result, scale, bias, dtype=return_dtype, result_shape=mm_output_shape) + else: + result = dequantize_symmetric(result, scale, dtype=return_dtype, result_shape=mm_output_shape) if conv_type == 1: result = result.transpose_(1,2) diff --git a/modules/sdnq/layers/conv/conv_fp8.py b/modules/sdnq/layers/conv/conv_fp8.py index 23afc9cf3..8f0147f52 100644 --- a/modules/sdnq/layers/conv/conv_fp8.py +++ b/modules/sdnq/layers/conv/conv_fp8.py @@ -3,6 +3,7 @@ import torch from ...common import compile_func +from ...kernel_wrappers import fp8_mm_func, fp8_scaled_mm_func from ...dequantizer import dequantize_symmetric, dequantize_asymmetric from ...quant_utils import rotate_hadamard, get_hadamard from ...packed_float import unpack_float @@ -46,21 +47,20 @@ def conv_fp8_matmul( input, input_scale = quantize_fp_mm_input(input, dtype=scale.dtype) input, weight = check_mats(input, weight) - dummy_input_scale = torch.ones(1, device=input.device, dtype=torch.float32) if groups == 1: - result = torch._scaled_mm(input, weight, scale_a=dummy_input_scale, scale_b=dummy_input_scale, bias=None, out_dtype=input_scale.dtype).mul_(input_scale) + result = fp8_scaled_mm_func(input, weight, input_scale, scale, bias=bias, out_dtype=return_dtype).view(mm_output_shape) else: weight = weight.view(weight.shape[0], groups, weight.shape[1] // groups) input = input.view(input.shape[0], groups, input.shape[1] // groups) result = [] for i in range(groups): - result.append(torch._scaled_mm(input[:, i], weight[:, i], scale_a=dummy_input_scale, scale_b=dummy_input_scale, bias=None, out_dtype=input_scale.dtype)) - result = torch.cat(result, dim=-1).mul_(input_scale) - if bias is not None: - dequantize_asymmetric(result, scale, bias, dtype=return_dtype, result_shape=mm_output_shape) - else: - dequantize_symmetric(result, scale, dtype=return_dtype, result_shape=mm_output_shape) + result.append(fp8_mm_func(input[:, i], weight[:, i])) + result = torch.cat(result, dim=-1).to(dtype=input_scale.dtype).mul_(input_scale) + if bias is not None: + result = dequantize_asymmetric(result, scale, bias, dtype=return_dtype, result_shape=mm_output_shape) + else: + result = dequantize_symmetric(result, scale, dtype=return_dtype, result_shape=mm_output_shape) if conv_type == 1: result = result.transpose_(1,2) diff --git a/modules/sdnq/layers/conv/conv_fp8_scaled.py b/modules/sdnq/layers/conv/conv_fp8_scaled.py deleted file mode 100644 index 8ed336e68..000000000 --- a/modules/sdnq/layers/conv/conv_fp8_scaled.py +++ /dev/null @@ -1,108 +0,0 @@ -# pylint: disable=relative-beyond-top-level,redefined-builtin,protected-access - -import torch - -from ...common import compile_func -from ...quant_utils import rotate_hadamard, get_hadamard -from ...packed_float import unpack_float - -from .forward import get_conv_args, process_conv_input -from ..linear.linear_fp8_scaled import quantize_fp_scaled_mm_input -from ..linear.forward import check_mats - - -def conv_fp8_scaled_matmul( - input: torch.FloatTensor, - weight: torch.Tensor, - scale: torch.FloatTensor, - result_shape: torch.Size, - reversed_padding_repeated_twice: list[int], - padding_mode: str, conv_type: int, - groups: int, stride: list[int], - padding: list[int], dilation: list[int], - bias: torch.FloatTensor | None = None, - svd_up: torch.FloatTensor | None = None, - svd_down: torch.FloatTensor | None = None, - hadamard: torch.FloatTensor | None = None, - quantized_weight_shape: torch.Size | None = None, - weights_dtype: str | None = None, -) -> torch.FloatTensor: - return_dtype = input.dtype - input, mm_output_shape = process_conv_input(conv_type, input, reversed_padding_repeated_twice, padding_mode, result_shape, stride, padding, dilation) - - if quantized_weight_shape is not None: - weight = unpack_float(weight, weights_dtype, quantized_weight_shape).to(dtype=torch.float8_e4m3fn).t_() - scale = scale.t() - - if hadamard is not None: - input = rotate_hadamard(input, hadamard=hadamard) - if svd_up is not None: - input = input.flatten(0,-2) - svd_bias = torch.mm(torch.mm(input.to(dtype=svd_down.dtype), svd_down), svd_up) - input, input_scale = quantize_fp_scaled_mm_input(input) - input, weight = check_mats(input, weight) - - if groups == 1: - if bias is not None and bias.dtype != torch.bfloat16: - bias = bias.to(dtype=torch.bfloat16) - result = torch._scaled_mm(input, weight, scale_a=input_scale, scale_b=scale, bias=bias, out_dtype=torch.bfloat16) - else: - scale = scale.view(groups, 1, scale.shape[1] // groups) - input_scale = input_scale.view(groups, input_scale.shape[0] // groups, 1) - weight = weight.view(weight.shape[0], groups, weight.shape[1] // groups) - input = input.view(input.shape[0], groups, input.shape[1] // groups) - result = [] - if bias is not None: - bias = bias.view(groups, bias.shape[0] // groups) - if bias.dtype != torch.bfloat16: - bias = bias.to(dtype=torch.bfloat16) - for i in range(groups): - result.append(torch._scaled_mm(input[:, i], weight[:, i], scale_a=input_scale[i], scale_b=scale[i], bias=bias[i], out_dtype=torch.bfloat16)) - else: - for i in range(groups): - result.append(torch._scaled_mm(input[:, i], weight[:, i], scale_a=input_scale[i], scale_b=scale[i], bias=None, out_dtype=torch.bfloat16)) - result = torch.cat(result, dim=-1) - if svd_up is not None: - result.add_(svd_bias) - result = result.view(mm_output_shape).to(return_dtype) - - if conv_type == 1: - result = result.transpose_(1,2) - elif conv_type == 2: - result = result.permute(0,3,1,2) - elif conv_type == 3: - result = result.permute(0,4,1,2,3) - return result - - -def quantized_conv_forward_fp8_scaled_matmul(self, input) -> torch.FloatTensor: - if torch.numel(input) / input.shape[2] < 32: - return self._conv_forward(input, self.sdnq_dequantizer(self.weight, self.scale, zero_point=self.zero_point, svd_up=self.svd_up, svd_down=self.svd_down, skip_quantized_matmul=True), self.bias) - if self.sdnq_dequantizer.re_quantize_for_matmul: - weight, scale = self.sdnq_dequantizer.re_quantize_matmul(self.weight, self.scale, zero_point=self.zero_point) - quantized_weight_shape = None - else: - weight, scale = self.weight, self.scale - quantized_weight_shape = self.sdnq_dequantizer.quantized_weight_shape if self.sdnq_dequantizer.is_packed else None - if self.sdnq_dequantizer.use_hadamard: - hadamard = get_hadamard(self.sdnq_dequantizer.hadamard_group_size, dtype=input.dtype, device=input.device) - else: - hadamard = None - - conv_type, stride, padding, dilation = get_conv_args(input.ndim, self.stride, self.padding, self.dilation) - return conv_fp8_scaled_matmul( - input, weight, scale, - self.sdnq_dequantizer.result_shape, - self._reversed_padding_repeated_twice, - self.padding_mode, conv_type, - self.groups, stride, padding, dilation, - bias=self.bias, - svd_up=self.svd_up, - svd_down=self.svd_down, - hadamard=hadamard, - quantized_weight_shape=quantized_weight_shape, - weights_dtype=self.sdnq_dequantizer.weights_dtype, - ) - - -conv_fp8_scaled_matmul = compile_func(conv_fp8_scaled_matmul) diff --git a/modules/sdnq/layers/conv/conv_int8.py b/modules/sdnq/layers/conv/conv_int8.py index e95ba9990..a35c5a9e4 100644 --- a/modules/sdnq/layers/conv/conv_int8.py +++ b/modules/sdnq/layers/conv/conv_int8.py @@ -2,7 +2,8 @@ import torch -from ...common import compile_func, int_mm_func +from ...common import compile_func +from ...kernel_wrappers import int_mm_func, int_scaled_mm_func from ...dequantizer import dequantize_symmetric, dequantize_asymmetric from ...quant_utils import rotate_hadamard, get_hadamard from ...packed_int import unpack_int @@ -64,7 +65,7 @@ def conv_int8_matmul( input, weight = check_mats(input, weight) if groups == 1: - result = int_mm_func(input, weight).to(dtype=input_scale.dtype).mul_(input_scale) + result = int_scaled_mm_func(input, weight, input_scale, scale, bias=bias, out_dtype=return_dtype).view(mm_output_shape) else: weight = weight.view(weight.shape[0], groups, weight.shape[1] // groups) input = input.view(input.shape[0], groups, input.shape[1] // groups) @@ -72,10 +73,10 @@ def conv_int8_matmul( for i in range(groups): result.append(int_mm_func(input[:, i], weight[:, i])) result = torch.cat(result, dim=-1).to(dtype=input_scale.dtype).mul_(input_scale) - if bias is not None: - result = dequantize_asymmetric(result, scale, bias, dtype=return_dtype, result_shape=mm_output_shape) - else: - result = dequantize_symmetric(result, scale, dtype=return_dtype, result_shape=mm_output_shape) + if bias is not None: + result = dequantize_asymmetric(result, scale, bias, dtype=return_dtype, result_shape=mm_output_shape) + else: + result = dequantize_symmetric(result, scale, dtype=return_dtype, result_shape=mm_output_shape) if conv_type == 1: result = result.transpose_(1,2) diff --git a/modules/sdnq/layers/conv/conv_uint8.py b/modules/sdnq/layers/conv/conv_uint8.py index 615430e55..a87beb0eb 100644 --- a/modules/sdnq/layers/conv/conv_uint8.py +++ b/modules/sdnq/layers/conv/conv_uint8.py @@ -2,7 +2,8 @@ import torch -from ...common import compile_func, int_mm_func +from ...common import compile_func +from ...kernel_wrappers import int_mm_func, int_scaled_mm_func from ...dequantizer import dequantize_asymmetric from ...quant_utils import rotate_hadamard, get_hadamard from ...packed_int import unpack_int @@ -67,7 +68,7 @@ def conv_uint8_matmul( input, weight = check_mats(input, weight) if groups == 1: - result = int_mm_func(input, weight).to(dtype=input_scale.dtype).mul_(input_scale) + result = int_scaled_mm_func(input, weight, input_scale, scale, bias=zero_bias, out_dtype=return_dtype).view(mm_output_shape) else: weight = weight.view(weight.shape[0], groups, weight.shape[1] // groups) input = input.view(input.shape[0], groups, input.shape[1] // groups) @@ -75,7 +76,7 @@ def conv_uint8_matmul( for i in range(groups): result.append(int_mm_func(input[:, i], weight[:, i])) result = torch.cat(result, dim=-1).to(dtype=input_scale.dtype).mul_(input_scale) - result = dequantize_asymmetric(result, scale, zero_bias, dtype=return_dtype, result_shape=mm_output_shape) + result = dequantize_asymmetric(result, scale, zero_bias, dtype=return_dtype, result_shape=mm_output_shape) if conv_type == 1: result = result.transpose_(1,2) diff --git a/modules/sdnq/layers/linear/forward.py b/modules/sdnq/layers/linear/forward.py index dbdee7521..1a323f0a1 100644 --- a/modules/sdnq/layers/linear/forward.py +++ b/modules/sdnq/layers/linear/forward.py @@ -2,7 +2,7 @@ import torch -from ...common import use_contiguous_int8_mm, use_contiguous_fp16_mm +from ...kernel_wrappers import use_contiguous_int8_mm, use_contiguous_fp16_mm def check_mats(input: torch.Tensor, weight: torch.Tensor, allow_contiguous_mm: bool = True) -> tuple[torch.Tensor, torch.Tensor]: diff --git a/modules/sdnq/layers/linear/linear_fp16.py b/modules/sdnq/layers/linear/linear_fp16.py index fcfec43f9..e4835970c 100644 --- a/modules/sdnq/layers/linear/linear_fp16.py +++ b/modules/sdnq/layers/linear/linear_fp16.py @@ -2,8 +2,8 @@ import torch -from ...common import compile_func, fp_mm_func -from ...dequantizer import dequantize_symmetric, dequantize_asymmetric +from ...common import compile_func +from ...kernel_wrappers import fp_scaled_mm_func from ...quant_utils import rotate_hadamard, get_hadamard from ...packed_float import unpack_float @@ -29,6 +29,7 @@ def fp16_matmul( weight = weight.to(dtype=torch.float16) # fp8 weights return_dtype = input.dtype output_shape = (*input.shape[:-1], weight.shape[-1]) + if hadamard is not None: input = rotate_hadamard(input, hadamard=hadamard) if svd_up is not None: @@ -37,12 +38,10 @@ def fp16_matmul( bias = torch.addmm(bias.to(dtype=svd_down.dtype), torch.mm(input.to(dtype=svd_down.dtype), svd_down), svd_up) else: bias = torch.mm(torch.mm(input.to(dtype=svd_down.dtype), svd_down), svd_up) + input, input_scale = quantize_fp_mm_input(input, dtype=scale.dtype, matmul_dtype="float16") input, weight = check_mats(input, weight) - if bias is not None: - return dequantize_asymmetric(fp_mm_func(input, weight).to(dtype=input_scale.dtype).mul_(input_scale), scale, bias, dtype=return_dtype, result_shape=output_shape) - else: - return dequantize_symmetric(fp_mm_func(input, weight).to(dtype=input_scale.dtype).mul_(input_scale), scale, dtype=return_dtype, result_shape=output_shape) + return fp_scaled_mm_func(input, weight, input_scale, scale, bias=bias, out_dtype=return_dtype).view(output_shape) def quantized_linear_forward_fp16_matmul(self, input: torch.FloatTensor) -> torch.FloatTensor: diff --git a/modules/sdnq/layers/linear/linear_fp8.py b/modules/sdnq/layers/linear/linear_fp8.py index 4b5610e87..8c6de8312 100644 --- a/modules/sdnq/layers/linear/linear_fp8.py +++ b/modules/sdnq/layers/linear/linear_fp8.py @@ -3,7 +3,7 @@ import torch from ...common import compile_func -from ...dequantizer import dequantize_symmetric, dequantize_asymmetric +from ...kernel_wrappers import fp8_scaled_mm_func from ...quant_utils import quantize_fp_mm, rotate_hadamard, get_hadamard from ...packed_float import unpack_float @@ -36,6 +36,7 @@ def fp8_matmul( scale = scale.t() return_dtype = input.dtype output_shape = (*input.shape[:-1], weight.shape[-1]) + if hadamard is not None: input = rotate_hadamard(input, hadamard=hadamard) if svd_up is not None: @@ -44,13 +45,10 @@ def fp8_matmul( bias = torch.addmm(bias.to(dtype=svd_down.dtype), torch.mm(input.to(dtype=svd_down.dtype), svd_down), svd_up) else: bias = torch.mm(torch.mm(input.to(dtype=svd_down.dtype), svd_down), svd_up) - dummy_input_scale = torch.ones(1, device=input.device, dtype=torch.float32) + input, input_scale = quantize_fp_mm_input(input, dtype=scale.dtype) input, weight = check_mats(input, weight, allow_contiguous_mm=False) - if bias is not None: - return dequantize_asymmetric(torch._scaled_mm(input, weight, scale_a=dummy_input_scale, scale_b=dummy_input_scale, bias=None, out_dtype=input_scale.dtype).mul_(input_scale), scale, bias, dtype=return_dtype, result_shape=output_shape) - else: - return dequantize_symmetric(torch._scaled_mm(input, weight, scale_a=dummy_input_scale, scale_b=dummy_input_scale, bias=None, out_dtype=input_scale.dtype).mul_(input_scale), scale, dtype=return_dtype, result_shape=output_shape) + return fp8_scaled_mm_func(input, weight, input_scale, scale, bias=bias, out_dtype=return_dtype).view(output_shape) def quantized_linear_forward_fp8_matmul(self, input: torch.FloatTensor) -> torch.FloatTensor: diff --git a/modules/sdnq/layers/linear/linear_fp8_scaled.py b/modules/sdnq/layers/linear/linear_fp8_scaled.py deleted file mode 100644 index 949c58586..000000000 --- a/modules/sdnq/layers/linear/linear_fp8_scaled.py +++ /dev/null @@ -1,75 +0,0 @@ -# pylint: disable=relative-beyond-top-level,redefined-builtin,protected-access - -import torch - -from ...common import compile_func -from ...quant_utils import quantize_fp_mm, rotate_hadamard, get_hadamard -from ...packed_float import unpack_float - -from .forward import check_mats - - -def quantize_fp_scaled_mm_input(input: torch.FloatTensor, matmul_dtype: str = "float8_e4m3fn") -> tuple[torch.Tensor, torch.FloatTensor]: - input = input.flatten(0,-2).to(dtype=torch.float32) - input, input_scale = quantize_fp_mm(input, dim=-1, matmul_dtype=matmul_dtype) - return input, input_scale - - -def fp8_scaled_matmul( - input: torch.FloatTensor, - weight: torch.Tensor, - scale: torch.FloatTensor, - bias: torch.FloatTensor | None = None, - svd_up: torch.FloatTensor | None = None, - svd_down: torch.FloatTensor | None = None, - hadamard: torch.FloatTensor | None = None, - quantized_weight_shape: torch.Size | None = None, - weights_dtype: str | None = None, -) -> torch.FloatTensor: - if quantized_weight_shape is not None: - weight = unpack_float(weight, weights_dtype, quantized_weight_shape).to(dtype=torch.float8_e4m3fn).t_() - scale = scale.t() - return_dtype = input.dtype - output_shape = (*input.shape[:-1], weight.shape[-1]) - if hadamard is not None: - input = rotate_hadamard(input, hadamard=hadamard) - if svd_up is not None: - input = input.flatten(0,-2) - svd_bias = torch.mm(torch.mm(input.to(dtype=svd_down.dtype), svd_down), svd_up) - input, input_scale = quantize_fp_scaled_mm_input(input) - input, weight = check_mats(input, weight, allow_contiguous_mm=False) - if bias is not None and bias.dtype != torch.bfloat16: - bias = bias.to(dtype=torch.bfloat16) - result = torch._scaled_mm(input, weight, scale_a=input_scale, scale_b=scale, bias=bias, out_dtype=torch.bfloat16) - if svd_up is not None: - result.add_(svd_bias) - result = result.view(output_shape).to(return_dtype) - return result - - -def quantized_linear_forward_fp8_scaled_matmul(self, input: torch.FloatTensor) -> torch.FloatTensor: - if torch.numel(input) / input.shape[-1] < 32: - return torch.nn.functional.linear(input, self.sdnq_dequantizer(self.weight, self.scale, zero_point=self.zero_point, svd_up=self.svd_up, svd_down=self.svd_down, skip_quantized_matmul=True), self.bias) - if self.sdnq_dequantizer.re_quantize_for_matmul: - weight, scale = self.sdnq_dequantizer.re_quantize_matmul(self.weight, self.scale, zero_point=self.zero_point) - quantized_weight_shape = None - else: - weight, scale = self.weight, self.scale - quantized_weight_shape = self.sdnq_dequantizer.quantized_weight_shape if self.sdnq_dequantizer.is_packed else None - if self.sdnq_dequantizer.use_hadamard: - hadamard = get_hadamard(self.sdnq_dequantizer.hadamard_group_size, dtype=input.dtype, device=input.device) - else: - hadamard = None - - return fp8_scaled_matmul( - input, weight, scale, - bias=self.bias, - svd_up=self.svd_up, - svd_down=self.svd_down, - hadamard=hadamard, - quantized_weight_shape=quantized_weight_shape, - weights_dtype=self.sdnq_dequantizer.weights_dtype, - ) - - -fp8_scaled_matmul = compile_func(fp8_scaled_matmul) diff --git a/modules/sdnq/layers/linear/linear_int8.py b/modules/sdnq/layers/linear/linear_int8.py index 9c72e22e6..9f39d624b 100644 --- a/modules/sdnq/layers/linear/linear_int8.py +++ b/modules/sdnq/layers/linear/linear_int8.py @@ -2,19 +2,19 @@ import torch -from ...common import compile_func, int_mm_func -from ...dequantizer import dequantize_symmetric, dequantize_asymmetric +from ...common import compile_func +from ...kernel_wrappers import int_scaled_mm_func from ...quant_utils import quantize_int_mm, rotate_hadamard, get_hadamard from ...packed_int import unpack_int from .forward import check_mats -def quantize_int_mm_input(input: torch.FloatTensor, dtype: torch.dtype | None = None) -> tuple[torch.Tensor, torch.FloatTensor]: +def quantize_int_mm_input(input: torch.FloatTensor, dtype: torch.dtype | None = None, matmul_dtype: str = "int8") -> tuple[torch.Tensor, torch.FloatTensor]: input = input.flatten(0,-2) if dtype is not None: input = input.to(dtype=dtype) - input, input_scale = quantize_int_mm(input, dim=-1) + input, input_scale = quantize_int_mm(input, dim=-1, matmul_dtype=matmul_dtype) if input_scale.dtype == torch.float16: # fp16 will overflow input_scale = input_scale.to(dtype=torch.float32) return input, input_scale @@ -64,12 +64,9 @@ def int8_matmul( if bias is not None: zero_bias.add_(bias) bias = zero_bias - input, weight = check_mats(input, weight) - if bias is not None: - return dequantize_asymmetric(int_mm_func(input, weight).to(dtype=input_scale.dtype).mul_(input_scale), scale, bias, dtype=return_dtype, result_shape=output_shape) - else: - return dequantize_symmetric(int_mm_func(input, weight).to(dtype=input_scale.dtype).mul_(input_scale), scale, dtype=return_dtype, result_shape=output_shape) + input, weight = check_mats(input, weight) + return int_scaled_mm_func(input, weight, input_scale, scale, bias=bias, out_dtype=return_dtype).view(output_shape) def quantized_linear_forward_int8_matmul(self, input: torch.FloatTensor) -> torch.FloatTensor: diff --git a/modules/sdnq/layers/linear/linear_uint8.py b/modules/sdnq/layers/linear/linear_uint8.py index 64693abe6..7812a8759 100644 --- a/modules/sdnq/layers/linear/linear_uint8.py +++ b/modules/sdnq/layers/linear/linear_uint8.py @@ -2,19 +2,19 @@ import torch -from ...common import compile_func, int_mm_func -from ...dequantizer import dequantize_asymmetric +from ...common import compile_func +from ...kernel_wrappers import int_scaled_mm_func from ...quant_utils import quantize_uint_mm, rotate_hadamard, get_hadamard from ...packed_int import unpack_int from .forward import check_mats -def quantize_uint_mm_input(input: torch.FloatTensor, dtype: torch.dtype | None = None) -> tuple[torch.Tensor, torch.FloatTensor, torch.FloatTensor]: +def quantize_uint_mm_input(input: torch.FloatTensor, dtype: torch.dtype | None = None, matmul_dtype: str = "uint8") -> tuple[torch.Tensor, torch.FloatTensor, torch.FloatTensor]: input = input.flatten(0,-2) if dtype is not None: input = input.to(dtype=dtype) - input, input_scale, input_zero_point = quantize_uint_mm(input, dim=-1) + input, input_scale, input_zero_point = quantize_uint_mm(input, dim=-1, matmul_dtype=matmul_dtype) if input_scale.dtype == torch.float16: # fp16 will overflow input_scale = input_scale.to(dtype=torch.float32) input_zero_point = input_zero_point.to(dtype=torch.float32) @@ -61,16 +61,16 @@ def uint8_matmul( input, input_scale, input_zero_point = quantize_uint_mm_input(input, dtype=scale.dtype) if zero_point is not None: - zero_bias = torch.sum(input, dim=-1, keepdim=True, dtype=torch.int32).to(input_scale.dtype).mul_(input_scale).mul(zero_point) - zero_bias.add_(torch.sum(weight, dim=0, keepdim=True, dtype=torch.int32).to(scale.dtype).mul_(scale).mul(input_zero_point)) + zero_bias = torch.sum(input, dim=-1, keepdim=True, dtype=torch.int32).to(dtype=input_scale.dtype).mul_(input_scale).mul(zero_point) + zero_bias.add_(torch.sum(weight, dim=0, keepdim=True, dtype=torch.int32).to(dtype=scale.dtype).mul_(scale).mul(input_zero_point)) zero_bias.add_(torch.mul(input_zero_point.mul_(input.shape[-1]), zero_point)) else: - zero_bias = torch.sum(weight, dim=0, keepdim=True, dtype=torch.int32).to(scale.dtype).mul_(scale).mul(input_zero_point) + zero_bias = torch.sum(weight, dim=0, keepdim=True, dtype=torch.int32).to(dtype=scale.dtype).mul_(scale).mul(input_zero_point) if bias is not None: zero_bias.add_(bias) input, weight = check_mats(input, weight) - return dequantize_asymmetric(int_mm_func(input, weight).to(dtype=input_scale.dtype).mul_(input_scale), scale, zero_bias, dtype=return_dtype, result_shape=output_shape) + return int_scaled_mm_func(input, weight, input_scale, scale, bias=zero_bias, out_dtype=return_dtype).view(output_shape) def quantized_linear_forward_uint8_matmul(self, input: torch.FloatTensor) -> torch.FloatTensor: diff --git a/modules/sdnq/loader.py b/modules/sdnq/loader.py index 04c6ad463..276c609cd 100644 --- a/modules/sdnq/loader.py +++ b/modules/sdnq/loader.py @@ -3,7 +3,8 @@ import json import torch from modules import shared -from .common import dtype_dict, is_fp8_mm_supported, use_tensorwise_fp8_matmul, check_torch_compile, linear_types +from .common import dtype_dict, check_torch_compile, linear_types +from .kernel_wrappers import is_fp8_mm_supported, use_tensorwise_fp8_matmul from .quantizer import QuantizationMethod, SDNQConfig, SDNQQuantizer, sdnq_post_load_quant from .quant_utils import prepare_weight_for_matmul, prepare_svd_for_matmul from .utils import get_quant_args_from_config, check_param_name_in @@ -286,10 +287,10 @@ def apply_sdnq_options_to_module( if current_use_quantized_matmul is not None: if current_use_quantized_matmul != module.sdnq_dequantizer.use_quantized_matmul: if not module.sdnq_dequantizer.re_quantize_for_matmul and not dtype_dict[module.sdnq_dequantizer.weights_dtype]["is_packed"]: - module.scale.t_() - module.weight.t_() + module.scale.data = module.scale.t_().contiguous() + module.weight.data = module.weight.t_() if module.zero_point is not None: - module.zero_point.t_() + module.zero_point.data = module.zero_point.t_().contiguous() if current_use_quantized_matmul: module.weight.data = prepare_weight_for_matmul(module.weight, matmul_dtype=module.sdnq_dequantizer.quantized_matmul_dtype) else: diff --git a/modules/sdnq/packed_float.py b/modules/sdnq/packed_float.py index 6e9c7a0f9..1d75afb31 100644 --- a/modules/sdnq/packed_float.py +++ b/modules/sdnq/packed_float.py @@ -37,7 +37,6 @@ def pack_float(x: torch.FloatTensor, weights_dtype: str) -> torch.Tensor: mantissa_mask = (1 << mantissa_difference) # pylint: disable=superfluous-parens x = x.to(dtype=torch.float32).view(torch.int32) - x = torch.where( torch.gt( torch.bitwise_and(x, -(1 << (mantissa_difference-4)) & ~(-mantissa_mask)), @@ -47,7 +46,22 @@ def pack_float(x: torch.FloatTensor, weights_dtype: str) -> torch.Tensor: x, ) - x = torch.where(torch.lt(x.view(torch.float32).abs(), dtype_dict[weights_dtype]["min_normal"]), 0, x) + if exponent_bits < 8: + min_normal = 2.0 ** (2 - (1 << (exponent_bits - 1))) + x_f32_abs = x.view(dtype=torch.float32).abs() + is_subnormal = torch.lt(x_f32_abs, min_normal) + x = torch.where( + is_subnormal, + torch.bitwise_or( + torch.bitwise_and(x, -2147483648), + torch.bitwise_left_shift( + x_f32_abs.mul_((1 << mantissa_bits) / min_normal).round_().to(torch.int32), + mantissa_difference, + ), + ), + x, + ) + del x_f32_abs, is_subnormal x = torch.bitwise_right_shift(x, mantissa_difference) x = torch.bitwise_and( @@ -105,5 +119,11 @@ def unpack_float(x: torch.Tensor, weights_dtype: str, shape: torch.Size) -> torc overflow_mask = (~(-(1 << (22 + exponent_bits))) | 1090519039) x = torch.where(torch.bitwise_and(x, overflow_mask).to(dtype=torch.bool), x, 0) x = x.view(torch.float32) - + if exponent_bits < 8: + min_normal = 2.0 ** (2 - (1 << (exponent_bits - 1))) + x = torch.where( + torch.lt(x.abs(), min_normal), + torch.sign(x).mul_(-min_normal).add_(x, alpha=2.0), + x, + ) return x diff --git a/modules/sdnq/quant_utils.py b/modules/sdnq/quant_utils.py index 54f74e2f9..b215275f9 100644 --- a/modules/sdnq/quant_utils.py +++ b/modules/sdnq/quant_utils.py @@ -1,10 +1,11 @@ # pylint: disable=redefined-builtin -import math import torch from modules import devices -from .common import dtype_dict, use_contiguous_int8_mm, use_contiguous_fp16_mm, conv_types, conv_transpose_types +from .common import dtype_dict, conv_types, conv_transpose_types +from .kernel_wrappers import use_contiguous_int8_mm, use_contiguous_fp16_mm +from .utils import is_pow2, is_pow4, next_power_of_2 @devices.inference_context() @@ -100,12 +101,12 @@ def build_hadamard_n4(n: int, dtype: torch.dtype | None = None, device: torch.de @devices.inference_context() def build_hadamard(n: int, dtype: torch.dtype | None = None, device: torch.device | None = None) -> torch.FloatTensor: - if math.log(n, 4).is_integer(): + if is_pow4(n): return build_hadamard_n4(n, device=device, dtype=dtype) - elif math.log(n, 2).is_integer(): + elif is_pow2(n): return build_hadamard_n2(n, device=device, dtype=dtype) else: - raise RuntimeError("Hadamard Group Size must be a power of 2.") + raise RuntimeError(f"Hadamard Group Size must be a power of 2 but got {n}.") # 256x256 Hadamard matrix is just 256 KB at FP32 @@ -140,10 +141,18 @@ def rotate_hadamard(weight: torch.Tensor, group_size: int = 256, hadamard: torch return result +def get_hadamard_group_size(channel_size: int, group_size: int) -> tuple[bool, int]: + group_size = next_power_of_2(min(channel_size, group_size)) + if channel_size % group_size != 0: + while channel_size % group_size != 0: + group_size = group_size // 2 + use_hadamard = group_size >= 4 + return use_hadamard, group_size + + @devices.inference_context() -def apply_hadamard(weight: torch.Tensor, group_size: int = 256, hadamard: torch.FloatTensor | None = None, layer_class_name: str | None = None) -> torch.Tensor: +def apply_hadamard(weight: torch.Tensor, group_size: int = 256, hadamard: torch.FloatTensor | None = None, layer_class_name: str | None = None) -> tuple[torch.Tensor, bool, int]: is_conv = False - use_hadamard = True if hadamard is not None: group_size = hadamard.shape[-1] if layer_class_name in conv_types or layer_class_name in conv_transpose_types: @@ -151,14 +160,7 @@ def apply_hadamard(weight: torch.Tensor, group_size: int = 256, hadamard: torch. channel_size = weight.shape[1] else: channel_size = weight.shape[-1] - group_size = min(group_size, channel_size) - if channel_size % group_size != 0: - hadamard_pow2 = int(math.log2(group_size)) - while channel_size % group_size != 0: - hadamard_pow2 -= 1 - group_size = 2 ** hadamard_pow2 - if group_size < 4: - use_hadamard = False + use_hadamard, group_size = get_hadamard_group_size(channel_size, group_size) if use_hadamard: if hadamard is not None and group_size != hadamard.shape[-1]: hadamard = None diff --git a/modules/sdnq/quantizer.py b/modules/sdnq/quantizer.py index a2f3f6ec8..66a4131fc 100644 --- a/modules/sdnq/quantizer.py +++ b/modules/sdnq/quantizer.py @@ -14,30 +14,43 @@ from accelerate import init_empty_weights from modules import devices, shared from .common import ( - sdnq_version, sdnq_keys, dtype_dict, accepted_weight_dtypes, accepted_matmul_dtypes, - allowed_types, linear_types, embedding_types, conv_types, conv_transpose_types, weights_dtype_order, - is_fp8_mm_supported, - use_tensorwise_fp8_matmul, check_torch_compile, compile_func, ) + +from .quant_utils import ( + quantize_weight, + apply_svdquant, + apply_hadamard, + prepare_weight_for_matmul, + prepare_svd_for_matmul, +) +from .utils import ( + check_param_name_in, + check_quant_is_allowed, + check_quantized_matmul_is_allowed, + get_quant_args_from_config, + get_quant_kwargs, + get_quantized_matmul_dtype, + add_module_skip_keys, +) + +from .kernel_wrappers import is_fp8_mm_supported, use_tensorwise_fp8_matmul from .dequantizer import SDNQDequantizer, dequantize_sdnq_model from .packed_int import pack_int from .packed_float import pack_float from .forward import get_forward_func from .layers import get_sdnq_wrapper_class - -from .quant_utils import quantize_weight, apply_svdquant, apply_hadamard, prepare_weight_for_matmul, prepare_svd_for_matmul -from .utils import check_param_name_in, get_quant_args_from_config, get_quant_kwargs, get_quantized_matmul_dtype, add_module_skip_keys +from .common import sdnq_version as current_sdnq_version class QuantizationMethod(str, Enum): @@ -101,7 +114,7 @@ def sdnq_quantize_layer_weight( is_conv_type = True reduction_axes = 1 output_channel_size, channel_size = weight.shape[:2] - use_quantized_matmul = use_quantized_matmul and channel_size >= 32 and output_channel_size >= 32 and output_channel_size % 16 == 0 and channel_size % 16 == 0 + use_quantized_matmul = check_quantized_matmul_is_allowed(use_quantized_matmul, output_channel_size, channel_size) if use_quantized_matmul and not re_quantize_for_matmul and not dtype_dict[weights_dtype]["is_packed"]: result_shape = weight.shape weight = weight.flatten(1,-1) @@ -115,7 +128,7 @@ def sdnq_quantize_layer_weight( is_linear_type = True reduction_axes = -1 output_channel_size, channel_size = weight.shape - use_quantized_matmul = use_quantized_matmul and channel_size >= 32 and output_channel_size >= 32 and output_channel_size % 16 == 0 and channel_size % 16 == 0 + use_quantized_matmul = check_quantized_matmul_is_allowed(use_quantized_matmul, output_channel_size, channel_size) else: if weight.ndim > 1: output_channel_size, channel_size = weight.shape[-2:] @@ -206,10 +219,10 @@ def sdnq_quantize_layer_weight( weight, scale, zero_point = quantize_weight(weight, reduction_axes, weights_dtype, dtype=(scale_dtype if cast_scale else None), use_stochastic_rounding=(use_stochastic_rounding and not skip_sr)) if transpose_weights: - scale.t_() - weight.t_() + scale = scale.t_().contiguous() + weight = weight.t_() if zero_point is not None: - zero_point.t_() + zero_point = zero_point.t_().contiguous() weight = prepare_weight_for_matmul(weight, matmul_dtype=quantized_matmul_dtype) quantized_weight_shape = weight.shape @@ -435,7 +448,7 @@ def sdnq_quantize_layer(layer: torch.nn.Module, quantization_config: "SDNQConfig @devices.inference_context() -def apply_sdnq_to_module(model: torch.nn.Module, quantization_config: "SDNQConfig", torch_dtype: torch.dtype | None = None, full_param_name: str = "") -> tuple[torch.nn.Module, "SDNQConfig"]: # pylint: disable=unused-argument +def apply_sdnq_to_module(model: torch.nn.Module, quantization_config: "SDNQConfig", torch_dtype: torch.dtype | None = None, pre_quantized: bool = False, full_param_name: str = "") -> tuple[torch.nn.Module, "SDNQConfig"]: # pylint: disable=unused-argument if not list(model.children()): return model, quantization_config for module_name, module in model.named_children(): @@ -445,21 +458,13 @@ def apply_sdnq_to_module(model: torch.nn.Module, quantization_config: "SDNQConfi param_name = module_name if hasattr(module, "weight") and module.weight is not None: param_name = param_name + ".weight" - layer_class_name = module.__class__.__name__ - param_in_modules_to_not_convert = check_param_name_in(param_name, quantization_config.modules_to_not_convert) - if ( - layer_class_name in allowed_types - and module.weight.dtype in {torch.float64, torch.float32, torch.float16, torch.bfloat16} - and param_in_modules_to_not_convert is None - and not (layer_class_name in embedding_types and not quantization_config.quant_embedding) - and not ((layer_class_name in conv_types or layer_class_name in conv_transpose_types) and not quantization_config.quant_conv) - ): - module, quantization_config = sdnq_quantize_layer(module, quantization_config, torch_dtype=torch_dtype, param_name=param_name) - setattr(model, module_name, module) - elif param_in_modules_to_not_convert is None: - quantization_config.modules_to_not_convert.append(param_name) - - module, quantization_config = apply_sdnq_to_module(module, quantization_config, torch_dtype=torch_dtype, full_param_name=param_name) + if check_param_name_in(param_name, quantization_config.modules_to_not_convert) is None: + if check_quant_is_allowed(module.__class__.__name__, module.weight, quantization_config, pre_quantized=pre_quantized): + module, quantization_config = sdnq_quantize_layer(module, quantization_config, torch_dtype=torch_dtype, param_name=param_name) + setattr(model, module_name, module) + else: + quantization_config.modules_to_not_convert.append(param_name) + module, quantization_config = apply_sdnq_to_module(module, quantization_config, torch_dtype=torch_dtype, pre_quantized=pre_quantized, full_param_name=param_name) setattr(model, module_name, module) return model, quantization_config @@ -485,6 +490,7 @@ def sdnq_post_load_quant( dequantize_fp32: bool = True, non_blocking: bool = False, add_skip_keys:bool = True, + minimum_allowed_numel: int = 16384, modules_to_not_convert: list[str] | None = None, modules_to_not_use_matmul: list[str] | None = None, modules_dtype_dict: dict[str, list[str]] | None = None, @@ -523,6 +529,7 @@ def sdnq_post_load_quant( dequantize_fp32=dequantize_fp32, non_blocking=non_blocking, add_skip_keys=add_skip_keys, + minimum_allowed_numel=minimum_allowed_numel, modules_to_not_convert=modules_to_not_convert, modules_to_not_use_matmul=modules_to_not_use_matmul, modules_dtype_dict=modules_dtype_dict, @@ -534,7 +541,7 @@ def sdnq_post_load_quant( model, quantization_config = add_module_skip_keys(model, quantization_config) model.eval() - model, quantization_config = apply_sdnq_to_module(model, quantization_config, torch_dtype=torch_dtype) + model, quantization_config = apply_sdnq_to_module(model, quantization_config, torch_dtype=torch_dtype, pre_quantized=pre_quantized) model.quantization_config = quantization_config if hasattr(model, "config"): @@ -602,17 +609,11 @@ class SDNQQuantizer(DiffusersQuantizer, HfQuantizer): return True elif param_name.endswith(".weight"): if check_param_name_in(param_name, self.quantization_config.modules_to_not_convert) is None: - layer_class_name = get_module_from_name(model, param_name)[0].__class__.__name__ - if layer_class_name in allowed_types: - if layer_class_name in embedding_types: - if self.quantization_config.quant_embedding: - return True - elif layer_class_name in conv_types or layer_class_name in conv_transpose_types: - if self.quantization_config.quant_conv: - return True - else: - return True - self.quantization_config.modules_to_not_convert.append(param_name) + layer = get_module_from_name(model, param_name)[0] + if check_quant_is_allowed(layer.__class__.__name__, layer.weight, self.quantization_config, pre_quantized=self.pre_quantized): + return True + else: + self.quantization_config.modules_to_not_convert.append(param_name) return False @devices.inference_context() @@ -865,10 +866,8 @@ class SDNQConfig(QuantizationConfigMixin): Enabling this option will use non blocking ops when moving layers between the quantization device and the return device. add_skip_keys (`bool`, *optional*, defaults to `True`): Disabling this option won't add model specific keys to modules_to_not_convert, modules_to_not_use_matmul and modules_dtype_dict. - quantization_device (`torch.device`, *optional*, defaults to `None`): - Used to set which device will be used for the quantization calculation on model load. - return_device (`torch.device`, *optional*, defaults to `None`): - Used to set which device will the quantized weights be sent back to. + minimum_allowed_numel (`int`, *optional*, defaults to `16384`): + Layers that have less than `minimum_allowed_numel` elements in them will be skipped and added to `modules_to_not_convert`. modules_to_not_convert (`list`, *optional*, default to `None`): The list of modules to not quantize. Useful for quantizing models that explicitly require to have some modules left in their original precision (e.g. Whisper encoder, Llava encoder, Mixtral gate layers). @@ -880,6 +879,10 @@ class SDNQConfig(QuantizationConfigMixin): modules_quant_config (`dict`, *optional*, default to `None`): The dict of modules and a dict of quantization kwargs to use for that module. Useful for quantizing some modules with a different quantization config. + quantization_device (`torch.device`, *optional*, defaults to `None`): + Used to set which device will be used for the quantization calculation on model load. + return_device (`torch.device`, *optional*, defaults to `None`): + Used to set which device will the quantized weights be sent back to. is_training (`bool`, *optional*, defaults to `False`): This option is auto enabled when using `sdnq.training.sdnq_training_post_load_quant`. Enabling this option with SDNQQuantizer will convert the model to SDNQ Training format after quantization. @@ -908,22 +911,20 @@ class SDNQConfig(QuantizationConfigMixin): dequantize_fp32: bool = True, non_blocking: bool = False, add_skip_keys: bool = True, - quantization_device: torch.device | None = None, - return_device: torch.device | None = None, + minimum_allowed_numel: int = 16384, modules_to_not_convert: list[str] | None = None, modules_to_not_use_matmul: list[str] | None = None, modules_dtype_dict: dict[str, list[str]] | None = None, modules_quant_config: dict[str, dict] | None = None, + quantization_device: torch.device | None = None, + return_device: torch.device | None = None, + sdnq_version: str | None = None, is_training: bool = False, **kwargs, ): self.weights_dtype = weights_dtype self.quantized_matmul_dtype = quantized_matmul_dtype self.is_training = is_training - if self.is_training: - self.quant_method = QuantizationMethod.SDNQ_TRAINING - else: - self.quant_method = QuantizationMethod.SDNQ self.hadamard_group_size = hadamard_group_size self.group_size = group_size self.svd_rank = svd_rank @@ -942,14 +943,19 @@ class SDNQConfig(QuantizationConfigMixin): self.dequantize_fp32 = dequantize_fp32 self.non_blocking = non_blocking self.add_skip_keys = add_skip_keys - self.quantization_device = quantization_device - self.return_device = return_device + self.minimum_allowed_numel = minimum_allowed_numel self.modules_to_not_convert = modules_to_not_convert self.modules_to_not_use_matmul = modules_to_not_use_matmul self.modules_dtype_dict = modules_dtype_dict self.modules_quant_config = modules_quant_config + self.quantization_device = quantization_device + self.return_device = return_device + self.sdnq_version = current_sdnq_version if sdnq_version is None else sdnq_version self.is_integer = dtype_dict[self.weights_dtype]["is_integer"] - self.sdnq_version = sdnq_version + if self.is_training: + self.quant_method = QuantizationMethod.SDNQ_TRAINING + else: + self.quant_method = QuantizationMethod.SDNQ self.post_init() def post_init(self) -> None: diff --git a/modules/sdnq/utils.py b/modules/sdnq/utils.py index f4ff60ba0..cc423432f 100644 --- a/modules/sdnq/utils.py +++ b/modules/sdnq/utils.py @@ -1,7 +1,29 @@ import re import torch -from .common import dtype_dict, common_skip_keys, module_skip_keys_dict, conv_types, conv_transpose_types +from .common import ( + dtype_dict, + common_skip_keys, + module_skip_keys_dict, + allowed_types, + embedding_types, + conv_types, + conv_transpose_types, +) + + +def is_pow2(n: int) -> bool: + return (n & (n - 1)) == 0 + + +def is_pow4(n: int) -> bool: + return is_pow2(n) and (n.bit_length() & 1 == 1) + + +def next_power_of_2(n: int) -> int: + if is_pow2(n): + return n + return 2 ** n.bit_length() def check_param_name_in(param_name: str, param_list: list[str]) -> str: @@ -21,6 +43,24 @@ def check_param_name_in(param_name: str, param_list: list[str]) -> str: return None +def check_quant_is_allowed(layer_class_name: str, weight: torch.Tensor, quantization_config, pre_quantized: bool = False) -> bool: + return bool( + layer_class_name in allowed_types + and weight.dtype in {torch.float64, torch.float32, torch.float16, torch.bfloat16} + and not (layer_class_name in embedding_types and not quantization_config.quant_embedding) + and not ((layer_class_name in conv_types or layer_class_name in conv_transpose_types) and not quantization_config.quant_conv) + and (pre_quantized or weight.numel() >= quantization_config.minimum_allowed_numel) + ) + + +def check_quantized_matmul_is_allowed(use_quantized_matmul: bool, output_channel_size: int, channel_size: int) -> bool: + return bool( + use_quantized_matmul + and output_channel_size >= 32 and channel_size >= 32 + and output_channel_size % 16 == 0 and channel_size % 16 == 0 + ) + + def get_quant_args_from_config(quantization_config: dict) -> dict: from .quantizer import SDNQConfig if isinstance(quantization_config, SDNQConfig): diff --git a/modules/shared_items.py b/modules/shared_items.py index 6999875c2..a8e8e55ec 100644 --- a/modules/shared_items.py +++ b/modules/shared_items.py @@ -179,5 +179,5 @@ def get_repo(model): return None -sdnq_quant_modes = ["int8", "uint8", "int6", "uint6", "uint5", "uint4", "uint3", "uint2", "float8_e4m3fn", "float8_e3m4fn", "float6_e3m2fn", "float5_e2m2fn", "float4_e2m1fn", "float3_e1m1fn", "float2_e1m0fn"] +sdnq_quant_modes = ["int8", "uint8", "int6", "uint6", "uint5", "uint4", "uint3", "uint2", "float8_e4m3fn", "float8_e3m4fn", "float6_e3m2fn", "float5_e2m2fn", "float4_e2m1fn", "float3_e1m1fn", "float2_e1m0fn", "int16", "uint16", "float16"] sdnq_matmul_modes = ["auto", "int8", "uint8", "float8_e4m3fn", "float16"] diff --git a/modules/ui_caption.py b/modules/ui_caption.py index a2598bdc2..caeae5daa 100644 --- a/modules/ui_caption.py +++ b/modules/ui_caption.py @@ -361,7 +361,7 @@ def create_ui(): with gr.Column(variant='compact', elem_id='caption_output'): with gr.Row(elem_id='caption_output_prompt'): - prompt = gr.Textbox(label="Answer", lines=12, placeholder="ai generated image description") + prompt = gr.Textbox(label="Answer", lines=12, placeholder="VLM generated image description") with gr.Row(elem_id='caption_output_image'): output_image = gr.Image(type='pil', label="Annotated Image", interactive=False, visible=False, elem_id='caption_output_image_display') with gr.Row(elem_id='caption_output_classes'): diff --git a/modules/ui_common.py b/modules/ui_common.py index 70ea58f90..0b52a673e 100644 --- a/modules/ui_common.py +++ b/modules/ui_common.py @@ -180,6 +180,8 @@ def save_files(js_data, files, html_info, index): if index < len(files): files = [files[index]] start_index = index + elif len(files) == 1: + start_index = 0 else: log.error(f'Save: index={index} first={p.index_of_first_image} files={len(files)} out of range') files = [] diff --git a/modules/ui_definitions.py b/modules/ui_definitions.py index 7d0ac016e..481c7435c 100644 --- a/modules/ui_definitions.py +++ b/modules/ui_definitions.py @@ -94,6 +94,7 @@ def create_settings(cmd_opts): "sd_model_checkpoint": OptionInfo(default_checkpoint, "Base model", DropdownEditable, lambda: {"choices": list_checkpoint_titles()}, refresh=refresh_checkpoints), "sd_model_refiner": OptionInfo('None', "Refiner model", gr.Dropdown, lambda: {"choices": ['None'] + list_checkpoint_titles()}, refresh=refresh_checkpoints), "sd_unet": OptionInfo("Default", "UNET model", gr.Dropdown, lambda: {"choices": shared_items.sd_unet_items()}, refresh=shared_items.refresh_unet_list), + "sd_unet_secondary": OptionInfo("Default", "UNET model secondary", gr.Dropdown, lambda: {"choices": shared_items.sd_unet_items()}, refresh=shared_items.refresh_unet_list), "latent_history": OptionInfo(20, "Latent history size", gr.Slider, {"minimum": 0, "maximum": 100, "step": 1}), "advanced_sep": OptionInfo("

Advanced Options

", "", gr.HTML), diff --git a/modules/ui_extra_networks.py b/modules/ui_extra_networks.py index ab7eba39d..301edaa94 100644 --- a/modules/ui_extra_networks.py +++ b/modules/ui_extra_networks.py @@ -774,7 +774,7 @@ def create_ui(container, button_parent: gr.Button, tabname: str, skip_indexing = def ui_tab_change(page): scan_visible = page in ['Model', 'Lora', 'VAE', 'UNet/DiT', 'Hypernetwork', 'Embedding'] save_visible = page in ['Style'] - model_visible = page in ['Model'] + model_visible = page in ['Model', 'UNet/DiT'] return [gr.update(visible=scan_visible), gr.update(visible=save_visible), gr.update(visible=model_visible)] ui.button_refresh = ui_components.ToolButton(ui_symbols.refresh, elem_id=f"{tabname}_extra_refresh") diff --git a/modules/ui_settings.py b/modules/ui_settings.py index b89b0d335..547273f2e 100644 --- a/modules/ui_settings.py +++ b/modules/ui_settings.py @@ -202,7 +202,7 @@ def run_settings_single(value, key, progress=False, force=False): shared.opts.save(silent=True) if key == 'sd_text_encoder': sd_models.reload_text_encoder() # apply the change now; reloads the model for encoders with no in-place swap - if key not in ['sd_model_checkpoint', 'sd_model_refiner', 'sd_vae', 'sd_te', 'sd_unet'] or force: + if key not in ['sd_model_checkpoint', 'sd_model_refiner', 'sd_vae', 'sd_te', 'sd_unet', 'sd_unet_secondary'] or force: log.debug(f'Setting changed: {key}="{value}" progress={progress} force={force}') return get_value_for_setting(key), shared.opts.dumpjson() @@ -442,7 +442,7 @@ def create_quicksettings(interfaces): ) button_set_refiner = gr.Button('Change refiner', elem_id='change_refiner', visible=False) button_set_refiner.click( - fn=lambda value, _: run_settings_single(value, key='sd_model_checkpoint'), + fn=lambda value, _: run_settings_single(value, key='sd_model_refiner'), _js="consumeDesiredCheckpointName", inputs=[shared.settings_components['sd_model_refiner'], dummy_component], outputs=[shared.settings_components['sd_model_refiner'], text_settings], @@ -461,6 +461,13 @@ def create_quicksettings(interfaces): inputs=[shared.settings_components["sd_unet"], dummy_component], outputs=[shared.settings_components["sd_unet"], text_settings], ) + button_set_unet_secondary = gr.Button("Change UNet secondary", elem_id="change_unet_secondary", visible=False) + button_set_unet_secondary.click( + fn=lambda value, _: run_settings_single(value, key="sd_unet_secondary"), + _js="consumeDesiredUNetName", + inputs=[shared.settings_components["sd_unet_secondary"], dummy_component], + outputs=[shared.settings_components["sd_unet_secondary"], text_settings], + ) def reference_submit(model): if '@' not in model: # diffusers diff --git a/modules/video_models/models_def.py b/modules/video_models/models_def.py index e2597fa0c..e1fa4d026 100644 --- a/modules/video_models/models_def.py +++ b/modules/video_models/models_def.py @@ -37,7 +37,7 @@ def getpipe(package, name, _default=None): cls = getattr(package, name, _default) return cls except Exception as e: - log.error(f'Video load: error loading class "{name}" from package "{package.__name__}": {e}') + log.error(f'Load video: error loading class "{name}" from package "{package.__name__}": {e}') return None diff --git a/modules/video_models/video_load.py b/modules/video_models/video_load.py index a1ccdcd5b..a0d003ada 100644 --- a/modules/video_models/video_load.py +++ b/modules/video_models/video_load.py @@ -22,7 +22,7 @@ loaded_model = None def load_custom(model_name: str): - log.debug(f'Video load: module=pipe repo="{model_name}" cls=Custom') + log.debug(f'Load video: module=pipe repo="{model_name}" cls=Custom') if 'veo-3.1' in model_name: from modules.video_models.google_veo import load_veo pipe = load_veo(model_name) @@ -48,7 +48,7 @@ def load_model(selected: models_def.Model): # shared.sd_model auto-reloads the default checkpoint when model_data.sd_model is None, # which silently swaps the pipe class behind the name-based cache. Pipe-class mismatch # is the reliable signal that the cached name no longer maps to the cached object. - log.warning(f'Video load: cached model="{selected.name}" cls={type(shared.sd_model).__name__} mismatch forcing reload') + log.warning(f'Load video: cached model="{selected.name}" cls={type(shared.sd_model).__name__} mismatch forcing reload') loaded_model = None if loaded_model == selected.name: return '' @@ -104,7 +104,7 @@ def load_model(selected: models_def.Model): selected.te_folder = 'text_encoder' selected.te_revision = None - log.debug(f'Video load: module=te repo="{selected.te or selected.repo}" folder="{selected.te_folder}" cls={selected.te_cls.__name__} quant={model_quant.get_quant_type(quant_args)} loader={_loader("transformers")}') + log.debug(f'Load video: module=te repo="{selected.te or selected.repo}" folder="{selected.te_folder}" cls={selected.te_cls.__name__} quant={model_quant.get_quant_type(quant_args)} loader={_loader("transformers")}') kwargs["text_encoder"] = selected.te_cls.from_pretrained( pretrained_model_name_or_path=selected.te or selected.repo, subfolder=selected.te_folder, @@ -125,7 +125,7 @@ def load_model(selected: models_def.Model): if dit_folder is not None and dit_folder not in kwargs: # get a new quant arg on every loop to prevent the quant config classes getting entangled load_args, quant_args = model_quant.get_dit_args({}, module='Model', device_map=True) - log.debug(f'Video load: module=transformer repo="{selected.dit or selected.repo}" module="{dit_folder}" folder="{dit_folder}" cls={selected.dit_cls.__name__} quant={model_quant.get_quant_type(quant_args)} loader={_loader("diffusers")}') + log.debug(f'Load video: module=transformer repo="{selected.dit or selected.repo}" module="{dit_folder}" folder="{dit_folder}" cls={selected.dit_cls.__name__} quant={model_quant.get_quant_type(quant_args)} loader={_loader("diffusers")}') kwargs[dit_folder] = selected.dit_cls.from_pretrained( pretrained_model_name_or_path=selected.dit or selected.repo, subfolder=dit_folder, @@ -136,7 +136,7 @@ def load_model(selected: models_def.Model): **offline_args, ) else: - log.debug(f'Video load: module=transformer repo="{selected.dit or selected.repo}" module="{dit_folder}" folder="{dit_folder}" cls={selected.dit_cls.__name__} loader={_loader("diffusers")} skip') + log.debug(f'Load video: module=transformer repo="{selected.dit or selected.repo}" module="{dit_folder}" folder="{dit_folder}" cls={selected.dit_cls.__name__} loader={_loader("diffusers")} skip') if selected.dit_folder is None: selected.dit_folder = ['transformer'] @@ -154,7 +154,10 @@ def load_model(selected: models_def.Model): if selected.repo_cls is None: shared.sd_model = load_custom(selected.repo) else: - log.debug(f'Video load: module=pipe repo="{selected.repo}" cls={selected.repo_cls.__name__}') + log.debug(f'Load video: module=pipe repo="{selected.repo}" cls={selected.repo_cls.__name__}') + print('HERE1') + sd_models.hf_prefetch_configs(selected.repo, {}, 'video') + print('HERE2') shared.sd_model = selected.repo_cls.from_pretrained( pretrained_model_name_or_path=selected.repo, revision=selected.repo_revision, @@ -168,7 +171,7 @@ def load_model(selected: models_def.Model): errors.display(e, 'video') if shared.sd_model is None: - msg = f'Video load: model="{selected.name}" failed' + msg = f'Load video: model="{selected.name}" failed' log.error(msg) return msg @@ -211,7 +214,7 @@ def load_model(selected: models_def.Model): sd_models.set_diffuser_offload(shared.sd_model) loaded_model = selected.name - msg = f'Video load: cls={shared.sd_model.__class__.__name__} model="{selected.name}" time={t1-t0:.2f}' + msg = f'Load video: cls={shared.sd_model.__class__.__name__} model="{selected.name}" time={t1-t0:.2f}' log.info(msg) log.debug(f'Video hijacks: decode={decode} text={text} image={image} slicing={slicing} tiling={tiling} framewise={framewise}') shared.state.end(jobid) diff --git a/modules/video_models/video_overrides.py b/modules/video_models/video_overrides.py index 6d918b617..cdd9c9036 100644 --- a/modules/video_models/video_overrides.py +++ b/modules/video_models/video_overrides.py @@ -36,10 +36,10 @@ def load_override(selected: Model, **load_args): from diffusers.pipelines.ltx2 import LTX2TextConnectors ltx2_connectors_cls = LTX2TextConnectors except ImportError as e: - log.warning(f'Video load: LTX2TextConnectors unavailable ({e}); dedup of LTX-2.3 connectors disabled') + log.warning(f'Load video: LTX2TextConnectors unavailable ({e}); dedup of LTX-2.3 connectors disabled') if ('LTXVideo 2.3' in selected.name and shared.opts.te_shared_te and ltx2_connectors_cls is not None): conn_repo = 'OzzyGT/LTX-2.3-sdnq-dynamic-int4' if 'SDNQ' in selected.name else 'OzzyGT/LTX-2.3' - log.debug(f'Video load: module=connectors repo="{conn_repo}" cls={ltx2_connectors_cls.__name__} shared={shared.opts.te_shared_te}') + log.debug(f'Load video: module=connectors repo="{conn_repo}" cls={ltx2_connectors_cls.__name__} shared={shared.opts.te_shared_te}') kwargs['connectors'] = ltx2_connectors_cls.from_pretrained( conn_repo, subfolder='connectors', diff --git a/modules/video_models/video_ui.py b/modules/video_models/video_ui.py index a546ba45e..7b65111be 100644 --- a/modules/video_models/video_ui.py +++ b/modules/video_models/video_ui.py @@ -41,7 +41,7 @@ def model_change(engine, model): def model_load(engine, model): - debug(f'Video load: engine="{engine}" model="{model}"') + debug(f'Load video: engine="{engine}" model="{model}"') selected = get_selected(engine, model) yield f'Video model loading: {selected.name}' if selected: diff --git a/pipelines/anima/anima_lora.py b/pipelines/anima/anima_lora.py index cc9c01dbf..cea98faa8 100644 --- a/pipelines/anima/anima_lora.py +++ b/pipelines/anima/anima_lora.py @@ -51,6 +51,10 @@ ANIMA_PREFIXES = ( "diffusion_model.", "lora_te_", "lora_unet_", + # LyCORIS-standalone save format; resolved by the universal passthrough in + # native_adapter.resolve_group_targets and routed to lora_transformer_ by + # network_prefix_for's default arm. + "lycoris_", ) diff --git a/pipelines/chroma/chroma_lora.py b/pipelines/chroma/chroma_lora.py index 8a95a69eb..3cd0395a6 100644 --- a/pipelines/chroma/chroma_lora.py +++ b/pipelines/chroma/chroma_lora.py @@ -4,12 +4,15 @@ Runs when :func:`modules.lora.lora_overrides.get_method` returns ``'native'`` (``lora_force_diffusers`` off and ``chroma`` in ``allow_native``). Entry points, one per family: :func:`try_load_lora` (plus DoRA), -:func:`try_load_lokr`, :func:`try_load_loha`, :func:`try_load_oft`. +:func:`try_load_lokr`, :func:`try_load_loha`, :func:`try_load_oft`, +:func:`try_load_ia3`, :func:`try_load_glora`, :func:`try_load_norm`, +:func:`try_load_full`. Recognized key prefixes: ``diffusion_model.``, ``transformer.``, -``lora_unet_``, plus bare BFL paths (``double_blocks.`` / ``single_blocks.``) -and bare diffusers paths (``transformer_blocks.`` / -``single_transformer_blocks.`` / ``distilled_guidance_layer.``). +``lora_unet_``, ``lycoris_``, plus bare BFL paths (``double_blocks.`` / +``single_blocks.`` / ``img_in.`` / ``txt_in.`` / ``final_layer.`` / +``distilled_guidance_layer.``) and bare diffusers paths +(``transformer_blocks.`` / ``single_transformer_blocks.``). Chroma LoRAs are trained against the Flux block layout regardless of save format. The diffusers ``ChromaTransformer2DModel`` exposes split-attention @@ -26,8 +29,11 @@ Fused weight handling: Chroma's modulation generator is the central ``distilled_guidance_layer`` approximator (replacing Flux's per-block ``norm1.linear``). The pruned ``ChromaAdaLayerNormZeroPruned`` classes have no ``.linear`` submodule, so -any ``_mod_lin`` / ``_modulation_lin`` keys land in ``unmapped``. LoRAs -targeting the approximator pass through unchanged. +any ``_mod_lin`` / ``_modulation_lin`` keys land in ``unmapped``. Approximator +keys pass through verbatim except the MLP leaves, where BFL +``layers.{i}.in_layer`` / ``out_layer`` rename to diffusers ``linear_1`` / +``linear_2``. Non-block embedder and final-layer keys rename via +``CHROMA_EXTRA_MAP``. """ from modules.lora import native_adapter @@ -38,11 +44,17 @@ from modules.lora.native_adapter import ChunkSpec KNOWN_PREFIXES = native_adapter.KNOWN_PREFIXES_DEFAULT -BARE_FLUX_PREFIXES = ("double_blocks.", "single_blocks.") +# distilled_guidance_layer. is deliberately a bare-BFL prefix, not a +# bare-diffusers one: the resolver renames BFL MLP leaves (in_layer/out_layer) +# and passes diffusers-named leaves (linear_1/linear_2, in_proj, out_proj, +# norms.N) through verbatim, so both namings route correctly. +BARE_FLUX_PREFIXES = ( + "double_blocks.", "single_blocks.", + "img_in.", "txt_in.", "final_layer.", "distilled_guidance_layer.", +) BARE_DIFFUSERS_PREFIXES = ( "transformer_blocks.", "single_transformer_blocks.", - "distilled_guidance_layer.", ) @@ -61,11 +73,19 @@ LORA_SUFFIXES = native_adapter.LORA_SUFFIXES LOKR_SUFFIXES = native_adapter.LOKR_SUFFIXES LOHA_SUFFIXES = native_adapter.LOHA_SUFFIXES OFT_SUFFIXES = native_adapter.OFT_SUFFIXES +IA3_SUFFIXES = native_adapter.IA3_SUFFIXES +GLORA_SUFFIXES = native_adapter.GLORA_SUFFIXES +NORM_SUFFIXES = native_adapter.NORM_SUFFIXES +FULL_SUFFIXES = native_adapter.FULL_SUFFIXES LORA_MARKERS = native_adapter.LORA_MARKERS LOKR_MARKERS = native_adapter.LOKR_MARKERS LOHA_MARKERS = native_adapter.LOHA_MARKERS OFT_MARKERS = native_adapter.OFT_MARKERS +IA3_MARKERS = native_adapter.IA3_MARKERS +GLORA_MARKERS = native_adapter.GLORA_MARKERS +NORM_MARKERS = native_adapter.NORM_MARKERS +FULL_MARKERS = native_adapter.FULL_MARKERS SUFFIX_NORMALIZE = native_adapter.SUFFIX_NORMALIZE BARE_DIFFUSERS_PREFIX_USED = native_adapter.BARE_DIFFUSERS_PREFIX_USED @@ -116,6 +136,13 @@ def resolve_targets(prefix_used, base): def _kohya_to_diffusers(base): """For kohya keys like ``double_blocks_0_img_attn_qkv`` or ``single_blocks_5_linear1``.""" + extra = CHROMA_EXTRA_KOHYA_MAP.get(base) + if extra is not None: + return [(extra, None)] + if base.startswith("distilled_guidance_layer_layers_"): + for bfl_leaf, dif_leaf in GUIDANCE_LEAF_MAP.items(): + if base.endswith("_" + bfl_leaf): + return [(base[:-len(bfl_leaf)] + dif_leaf, None)] if base.startswith("double_blocks_"): rest = base[len("double_blocks_"):] idx, _, suffix = rest.partition("_") @@ -129,6 +156,14 @@ def _kohya_to_diffusers(base): def _bfl_to_diffusers(base): """For BFL dotted keys like ``double_blocks.0.img_attn.qkv``.""" + extra = CHROMA_EXTRA_MAP.get(base) + if extra is not None: + return [(extra, None)] + if base.startswith("distilled_guidance_layer.layers."): + stem, _, leaf = base.rpartition(".") + mapped = GUIDANCE_LEAF_MAP.get(leaf) + if mapped is not None: + return [(f"{stem}.{mapped}", None)] parts = base.split(".") if len(parts) < 3: return [(base, None)] @@ -142,6 +177,27 @@ def _bfl_to_diffusers(base): return [(base, None)] +# Non-block BFL targets. Chroma prunes time_in/guidance_in/vector_in and the +# final-layer adaLN modulation, so only the embedders and the final projection +# need renames. None carry a block index, so the kohya form is derivable by +# underscoring the BFL path. +CHROMA_EXTRA_MAP = { + "img_in": "x_embedder", + "txt_in": "context_embedder", + "final_layer.linear": "proj_out", +} + +CHROMA_EXTRA_KOHYA_MAP = {k.replace(".", "_"): v for k, v in CHROMA_EXTRA_MAP.items()} + +# distilled_guidance_layer MLP leaves: BFL in_layer/out_layer vs diffusers +# PixArtAlphaTextProjection linear_1/linear_2. The other approximator leaves +# (in_proj, out_proj, norms.N) share names on both sides and pass verbatim. +GUIDANCE_LEAF_MAP = { + "in_layer": "linear_1", + "out_layer": "linear_2", +} + + # Static non-fused renames (underscore-keyed for dispatch from either kohya or BFL paths). _DOUBLE_STATIC = { "img_attn_proj": "attn.to_out.0", @@ -228,9 +284,28 @@ def try_load_oft(name, network_on_disk, lora_scale): return native_adapter.try_load_oft(name, network_on_disk, lora_scale, **_BIND_KWARGS) +def try_load_ia3(name, network_on_disk, lora_scale): + return native_adapter.try_load_ia3(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_glora(name, network_on_disk, lora_scale): + return native_adapter.try_load_glora(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_norm(name, network_on_disk, lora_scale): + return native_adapter.try_load_norm(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_full(name, network_on_disk, lora_scale): + return native_adapter.try_load_full(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + def try_load(name, network_on_disk, lora_scale): """Run every Chroma family loader, merge any that match.""" return native_adapter.try_load_chain( name, network_on_disk, lora_scale, - family_loaders=(try_load_lora, try_load_lokr, try_load_loha, try_load_oft), + family_loaders=( + try_load_lora, try_load_lokr, try_load_loha, try_load_oft, + try_load_ia3, try_load_glora, try_load_norm, try_load_full, + ), ) diff --git a/pipelines/ernie/ernie_lora.py b/pipelines/ernie/ernie_lora.py index e3eb3d842..b0b072be3 100644 --- a/pipelines/ernie/ernie_lora.py +++ b/pipelines/ernie/ernie_lora.py @@ -4,7 +4,9 @@ Runs when :func:`modules.lora.lora_overrides.get_method` returns ``'native'`` (``lora_force_diffusers`` off and ``ernieimage`` in ``allow_native``). Entry points, one per family: :func:`try_load_lora` (plus DoRA), -:func:`try_load_lokr`, :func:`try_load_loha`, :func:`try_load_oft`. +:func:`try_load_lokr`, :func:`try_load_loha`, :func:`try_load_oft`, +:func:`try_load_ia3`, :func:`try_load_glora`, :func:`try_load_norm`, +:func:`try_load_full`. Recognized key prefixes: ``diffusion_model.``, ``transformer.``, ``lora_unet_``, plus bare diffusers paths (``layers.``, ``adaLN_modulation.``, @@ -34,11 +36,19 @@ LORA_SUFFIXES = native_adapter.LORA_SUFFIXES LOKR_SUFFIXES = native_adapter.LOKR_SUFFIXES LOHA_SUFFIXES = native_adapter.LOHA_SUFFIXES OFT_SUFFIXES = native_adapter.OFT_SUFFIXES +IA3_SUFFIXES = native_adapter.IA3_SUFFIXES +GLORA_SUFFIXES = native_adapter.GLORA_SUFFIXES +NORM_SUFFIXES = native_adapter.NORM_SUFFIXES +FULL_SUFFIXES = native_adapter.FULL_SUFFIXES LORA_MARKERS = native_adapter.LORA_MARKERS LOKR_MARKERS = native_adapter.LOKR_MARKERS LOHA_MARKERS = native_adapter.LOHA_MARKERS OFT_MARKERS = native_adapter.OFT_MARKERS +IA3_MARKERS = native_adapter.IA3_MARKERS +GLORA_MARKERS = native_adapter.GLORA_MARKERS +NORM_MARKERS = native_adapter.NORM_MARKERS +FULL_MARKERS = native_adapter.FULL_MARKERS SUFFIX_NORMALIZE = native_adapter.SUFFIX_NORMALIZE BARE_DIFFUSERS_PREFIX_USED = native_adapter.BARE_DIFFUSERS_PREFIX_USED @@ -106,9 +116,28 @@ def try_load_oft(name, network_on_disk, lora_scale): return native_adapter.try_load_oft(name, network_on_disk, lora_scale, **_BIND_KWARGS) +def try_load_ia3(name, network_on_disk, lora_scale): + return native_adapter.try_load_ia3(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_glora(name, network_on_disk, lora_scale): + return native_adapter.try_load_glora(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_norm(name, network_on_disk, lora_scale): + return native_adapter.try_load_norm(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_full(name, network_on_disk, lora_scale): + return native_adapter.try_load_full(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + def try_load(name, network_on_disk, lora_scale): """Run every ERNIE family loader, merge any that match.""" return native_adapter.try_load_chain( name, network_on_disk, lora_scale, - family_loaders=(try_load_lora, try_load_lokr, try_load_loha, try_load_oft), + family_loaders=( + try_load_lora, try_load_lokr, try_load_loha, try_load_oft, + try_load_ia3, try_load_glora, try_load_norm, try_load_full, + ), ) diff --git a/pipelines/flux/flux2_lora.py b/pipelines/flux/flux2_lora.py index 622fe838e..681c65087 100644 --- a/pipelines/flux/flux2_lora.py +++ b/pipelines/flux/flux2_lora.py @@ -15,7 +15,8 @@ produced by ``Flux2Transformer2DModel.save_lora_adapter()``). Diffusers-PEFT ``.lora_A.default.weight``) is stripped to match the standard suffix table. BFL/kohya keys are mapped to diffusers paths via ``F2_SINGLE_MAP`` / -``F2_DOUBLE_MAP`` / ``F2_QKV_MAP``. Fused QKV in double_blocks emits three +``F2_DOUBLE_MAP`` / ``F2_QKV_MAP`` / ``F2_EXTRA_MAP`` (non-block targets: +embedders, modulation, final layer). Fused QKV in double_blocks emits three Q/K/V targets each carrying a :class:`modules.lora.native_adapter.ChunkSpec` that the generic loaders use to chunk the up-weight or instantiate the appropriate ``NetworkModule*Chunk`` variant. @@ -55,11 +56,11 @@ from modules.lora.native_adapter import ChunkSpec # === Arch-specific prefix configuration === -KNOWN_PREFIXES = native_adapter.KNOWN_PREFIXES_DEFAULT + ("lycoris_",) +KNOWN_PREFIXES = native_adapter.KNOWN_PREFIXES_DEFAULT BARE_FLUX_PREFIXES = ( "single_blocks.", "double_blocks.", "img_in.", "txt_in.", - "final_layer.", "time_in.", "single_stream_modulation.", + "final_layer.", "time_in.", "guidance_in.", "single_stream_modulation.", "double_stream_modulation_", ) @@ -92,6 +93,28 @@ F2_QKV_MAP = { "txt_attn.qkv": ("attn", ["add_q_proj", "add_k_proj", "add_v_proj"]), } +# Non-block BFL targets: embedders, timestep/guidance MLPs, modulation and the +# final layer. Exact-match on the full base. guidance_in resolves only on models +# built with guidance_embeds (the module is absent otherwise and the group is +# counted as unmapped). +F2_EXTRA_MAP = { + "img_in": "x_embedder", + "txt_in": "context_embedder", + "time_in.in_layer": "time_guidance_embed.timestep_embedder.linear_1", + "time_in.out_layer": "time_guidance_embed.timestep_embedder.linear_2", + "guidance_in.in_layer": "time_guidance_embed.guidance_embedder.linear_1", + "guidance_in.out_layer": "time_guidance_embed.guidance_embedder.linear_2", + "final_layer.linear": "proj_out", + "final_layer.adaLN_modulation.1": "norm_out.linear", + "single_stream_modulation.lin": "single_stream_modulation.linear", + "double_stream_modulation_img.lin": "double_stream_modulation_img.linear", + "double_stream_modulation_txt.lin": "double_stream_modulation_txt.linear", +} + +# Kohya underscores the full BFL path; non-block paths carry no index so the +# kohya form is derivable. +F2_EXTRA_KOHYA_MAP = {k.replace(".", "_"): v for k, v in F2_EXTRA_MAP.items()} + # Kohya underscore suffix -> BFL dot suffix. Used to convert kohya key fragments # to look up F2_DOUBLE_MAP / F2_QKV_MAP. KOHYA_SUFFIX_MAP = { @@ -160,31 +183,25 @@ def resolve_targets(prefix_used, base): """Return ``[(diffusers_path, ChunkSpec | None), ...]`` for a parsed group key. For ``lora_unet_`` prefix, applies ``KOHYA_SUFFIX_MAP`` then ``F2_*_MAP``. - For BFL / bare-BFL, applies ``F2_*_MAP`` directly. ``lycoris_`` is an - already-underscored diffusers path, returned verbatim. Unrecognized - prefixes return an empty list. + For BFL / bare-BFL, applies ``F2_*_MAP`` directly. Unrecognized prefixes + return an empty list. - Universal passthrough prefixes are handled upstream by - :func:`native_adapter.resolve_group_targets`. + Universal passthrough prefixes (including ``lycoris_``) are handled + upstream by :func:`native_adapter.resolve_group_targets`. """ if prefix_used == "lora_unet_": return _kohya_to_diffusers_targets(base) if prefix_used in (None, "diffusion_model."): return _bfl_to_diffusers_targets(base) - if prefix_used == "lycoris_": - # base is an already-underscored diffusers path (e.g. - # 'transformer_blocks_0_attn_add_k_proj'). The caller's network_key - # construction does base.replace('.', '_'); for already-underscored - # paths that's a no-op, so the network_key matches the entry stamped - # by lora_convert.assign_network_names_to_compvis_modules - # (e.g. 'lora_transformer_transformer_blocks_0_attn_add_k_proj'). - return [(base, None)] return [] def _kohya_to_diffusers_targets(stripped): """For kohya keys like ``double_blocks_0_img_attn_proj`` or ``single_blocks_5_linear1``.""" targets: list[tuple[str, ChunkSpec | None]] = [] + extra = F2_EXTRA_KOHYA_MAP.get(stripped) + if extra is not None: + return [(extra, None)] if stripped.startswith("single_blocks_"): rest = stripped[len("single_blocks_"):] idx, _, suffix = rest.partition("_") @@ -211,6 +228,9 @@ def _kohya_to_diffusers_targets(stripped): def _bfl_to_diffusers_targets(base): """For BFL keys like ``double_blocks.0.img_attn.proj`` or ``single_blocks.5.linear1``.""" targets: list[tuple[str, ChunkSpec | None]] = [] + extra = F2_EXTRA_MAP.get(base) + if extra is not None: + return [(extra, None)] parts = base.split(".") if len(parts) < 3: return targets diff --git a/pipelines/generic_transformer.py b/pipelines/generic_transformer.py index 142b5ce45..9de674781 100644 --- a/pipelines/generic_transformer.py +++ b/pipelines/generic_transformer.py @@ -21,10 +21,16 @@ def load_transformer( modules_dtype_dict=None, use_safetensors=True, native_spec=None, + override_slot='primary', **kwargs): """Load a DiT transformer from the base repo, or from a user-selected - single file when the UNET dropdown (``shared.opts.sd_unet``) is set. + single file when the slot's UNET override dropdown is set. + + ``override_slot`` selects which dropdown this call consumes: ``'primary'`` + reads ``shared.opts.sd_unet``, ``'secondary'`` reads + ``shared.opts.sd_unet_secondary`` (dual-transformer arches give each + transformer its own slot). With ``native_spec`` set and a .safetensors override selected, dispatches to :func:`pipelines.native_transformer.load`. Without a spec, a single-file @@ -69,14 +75,23 @@ def load_transformer( ) local_file = None + override_name = None fallback = True from modules import sd_unet - if shared.opts.sd_unet is not None and shared.opts.sd_unet != 'Default': - if shared.opts.sd_unet not in list(sd_unet.unet_dict): - log.error(f'Load module: type=transformer file="{shared.opts.sd_unet}" not found') - elif os.path.exists(sd_unet.unet_dict[shared.opts.sd_unet]): - local_file = sd_unet.unet_dict[shared.opts.sd_unet] + if override_slot == 'primary': + override_opt, tracker_attr = 'sd_unet', 'loaded_unet' + elif override_slot == 'secondary': + override_opt, tracker_attr = 'sd_unet_secondary', 'loaded_unet_secondary' + else: + raise ValueError(f'load_transformer: unknown override_slot={override_slot}') + selected = getattr(shared.opts, override_opt, None) + if selected is not None and selected != 'Default': + if selected not in list(sd_unet.unet_dict): + log.error(f'Load module: type=transformer slot={override_slot} file="{selected}" not found') + elif os.path.exists(sd_unet.unet_dict[selected]): + local_file = sd_unet.unet_dict[selected] + override_name = selected if repo_id.startswith(shared.opts.ckpt_dir) and os.path.exists(repo_id): log.error(f'Load model: transformer="{repo_id}" is incorrectly placed in the checkpoints folder') @@ -118,8 +133,8 @@ def load_transformer( log.warning(f'Load model: transformer="{local_file}" override incompatible with cls={cls_name.__name__} ({e})') if fallback: log.warning(f'Load model: transformer="{local_file}" ignoring override and loading base transformer') - shared.opts.data['sd_unet'] = 'Default' - sd_unet.loaded_unet = None + shared.opts.data[override_opt] = 'Default' + setattr(sd_unet, tracker_attr, None) transformer = load_from_repo() # 3. load safetensors with diffusers loader @@ -142,6 +157,11 @@ def load_transformer( else: transformer = load_from_repo() + # mark the dropdown selection as loaded so the slot's onchange callback + # does not force a redundant full reload for an already-consumed override + if transformer is not None and override_name is not None and getattr(shared.opts, override_opt, None) == override_name: + setattr(sd_unet, tracker_attr, override_name) + sd_models.allow_post_quant = False # we already handled it if shared.opts.diffusers_offload_mode != 'none' and transformer is not None: sd_models.move_model(transformer, devices.cpu) @@ -166,12 +186,15 @@ def load_transformer( log.debug(f'Load model: transformer="{repo_id}" quant="{quant_type}" size={module_size:.3f} params={param_num:.3f} memory={module_memory}') try: - actual_dtype = transformer.dtype - if isinstance(actual_dtype, torch.dtype) and isinstance(dtype, torch.dtype) and actual_dtype != dtype: - force = shared.opts.force_dtype - log.warning(f'Load model: transformer="{repo_id}" dtype desired={dtype} actual={actual_dtype} force={force}') - if force: - transformer = transformer.to(dtype) + # quantized models legitimately report the storage dtype (e.g. fp8 comfy_quant + # adopted via SDNQ); the compute dtype lives in the dequantizers, not the params + if getattr(transformer, 'quantization_config', None) is None: + actual_dtype = transformer.dtype + if isinstance(actual_dtype, torch.dtype) and isinstance(dtype, torch.dtype) and actual_dtype != dtype: + force = shared.opts.force_dtype + log.warning(f'Load model: transformer="{repo_id}" dtype desired={dtype} actual={actual_dtype} force={force}') + if force: + transformer = transformer.to(dtype) except Exception: pass diff --git a/pipelines/ideogram/__init__.py b/pipelines/ideogram/__init__.py new file mode 100644 index 000000000..f0b6585f7 --- /dev/null +++ b/pipelines/ideogram/__init__.py @@ -0,0 +1,62 @@ +"""Ideogram 4 native loader spec. + +Kept import-light: only the converter and spec live here so the native +loader can import them without pulling the pipeline or the qwen patch. +""" + +import re + +import torch +import diffusers + +from pipelines.native_transformer import TransformerSpec + + +QKV_TARGETS = ("to_q", "to_k", "to_v") +QKV_RE = re.compile(r"^(layers\.\d+\.attention)\.qkv\.(.+)$") +OUT_RE = re.compile(r"^(layers\.\d+\.attention)\.o\.(.+)$") + + +def convert_ideogram4_transformer_checkpoint(state_dict: dict, **kwargs) -> dict: # pylint: disable=unused-argument + """Fused community layout to ``Ideogram4Transformer2DModel`` layout. + + ``layers.N.attention.qkv.`` splits into ``to_q/to_k/to_v.``: + row-stacked tensors (weight, row-wise scale, bias) are dim-0 sliced into + thirds, non-row-stacked sidecars (markers, scalar scales) copied verbatim + to all three. ``attention.o.`` renames to ``attention.to_out.0.``, + everything else passes through. Returns a new dict; the input (which may + be the cached state dict) is not mutated. + """ + converted: dict = {} + for key, value in state_dict.items(): + fused_match = QKV_RE.match(key) + if fused_match is not None: + prefix, suffix = fused_match.group(1), fused_match.group(2) + fused_weight = state_dict.get(f"{prefix}.qkv.weight") + fused_rows = fused_weight.shape[0] if torch.is_tensor(fused_weight) and fused_weight.ndim >= 1 else None + row_stacked = ( + suffix != "comfy_quant" + and torch.is_tensor(value) and value.ndim >= 1 + and fused_rows is not None and value.shape[0] == fused_rows and fused_rows % 3 == 0 + ) + if row_stacked: + third = fused_rows // 3 + for i, target in enumerate(QKV_TARGETS): + converted[f"{prefix}.{target}.{suffix}"] = value[i * third:(i + 1) * third] + else: + for target in QKV_TARGETS: + converted[f"{prefix}.{target}.{suffix}"] = value + continue + out_match = OUT_RE.match(key) + if out_match is not None: + converted[f"{out_match.group(1)}.to_out.0.{out_match.group(2)}"] = value + continue + converted[key] = value + return converted + + +IDEOGRAM4_SPEC = TransformerSpec( + cls=diffusers.Ideogram4Transformer2DModel, + converter=convert_ideogram4_transformer_checkpoint, + converter_handles_quant=True, +) diff --git a/pipelines/ideogram/ideogram4.py b/pipelines/ideogram/ideogram4.py index 2efb45646..ed7b52533 100644 --- a/pipelines/ideogram/ideogram4.py +++ b/pipelines/ideogram/ideogram4.py @@ -161,6 +161,20 @@ def _expand_tensor_to_effective_batch( return torch.repeat_interleave(tensor, repeats=repeat_by, dim=0, output_size=tensor.shape[0] * repeat_by) +def transformer_compute_dtype(module: torch.nn.Module) -> torch.dtype: + """Activation dtype of a possibly-quantized transformer: sub-16-bit + floating params (e.g. fp8) surface through `module.dtype` but are a + storage format; the dequantizer's result dtype is the compute dtype.""" + dtype = module.dtype + if not dtype.is_floating_point or torch.finfo(dtype).bits >= 16: + return dtype + for m in module.modules(): + dequantizer = getattr(m, 'sdnq_dequantizer', None) + if dequantizer is not None: + return dequantizer.result_dtype + return dtype + + class Ideogram4Pipeline(DiffusionPipeline): r""" Text-to-image pipeline for Ideogram4. @@ -675,8 +689,10 @@ class Ideogram4Pipeline(DiffusionPipeline): # The transformers run in their loaded compute dtype; cast the (otherwise float32) text features to match. # `latents` stay float32 for scheduler precision and are cast per-step at the transformer call below. - llm_features = llm_features.to(self.transformer.dtype) - neg_llm_features = neg_llm_features.to(self.unconditional_transformer.dtype if self.unconditional_transformer else self.transformer.dtype) + cond_dtype = transformer_compute_dtype(self.transformer) + uncond_dtype = transformer_compute_dtype(self.unconditional_transformer) if self.unconditional_transformer is not None else cond_dtype + llm_features = llm_features.to(cond_dtype) + neg_llm_features = neg_llm_features.to(uncond_dtype) # 8. Denoising loop. The scheduler stores `num_train_timesteps`-scaled timesteps; convert back to model time. num_train_timesteps = self.scheduler.config.num_train_timesteps # pylint: disable=no-member @@ -687,10 +703,10 @@ class Ideogram4Pipeline(DiffusionPipeline): # Map sigma-domain timestep to model time `t` in [0, 1] (0 = noise, 1 = clean data). t_model = 1.0 - (t.float() / num_train_timesteps) - t_model = t_model.expand(batch_size * num_images_per_prompt).to(self.transformer.dtype) + t_model = t_model.expand(batch_size * num_images_per_prompt).to(cond_dtype) # Conditional pass operates on the full packed sequence. - pos_z = torch.cat([text_z_padding, latents], dim=1).to(self.transformer.dtype) + pos_z = torch.cat([text_z_padding, latents], dim=1).to(cond_dtype) pos_out = self.transformer( hidden_states=pos_z, timestep=t_model, @@ -710,7 +726,7 @@ class Ideogram4Pipeline(DiffusionPipeline): if gw[i] > 1.0: uncond_transformer = self.unconditional_transformer if self.unconditional_transformer is not None else self.transformer neg_v = uncond_transformer( - hidden_states=latents.to(uncond_transformer.dtype), + hidden_states=latents.to(uncond_dtype), timestep=t_model, encoder_hidden_states=neg_llm_features, position_ids=neg_position_ids, diff --git a/pipelines/krea2/krea2_lora.py b/pipelines/krea2/krea2_lora.py index 6f93e2f8e..c09348656 100644 --- a/pipelines/krea2/krea2_lora.py +++ b/pipelines/krea2/krea2_lora.py @@ -63,9 +63,28 @@ def try_load_oft(name, network_on_disk, lora_scale): return native_adapter.try_load_oft(name, network_on_disk, lora_scale, **_BIND_KWARGS) +def try_load_ia3(name, network_on_disk, lora_scale): + return native_adapter.try_load_ia3(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_glora(name, network_on_disk, lora_scale): + return native_adapter.try_load_glora(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_norm(name, network_on_disk, lora_scale): + return native_adapter.try_load_norm(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_full(name, network_on_disk, lora_scale): + return native_adapter.try_load_full(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + def try_load(name, network_on_disk, lora_scale): """Run every Krea 2 family loader, merge any that match.""" return native_adapter.try_load_chain( name, network_on_disk, lora_scale, - family_loaders=(try_load_lora, try_load_lokr, try_load_loha, try_load_oft), + family_loaders=( + try_load_lora, try_load_lokr, try_load_loha, try_load_oft, + try_load_ia3, try_load_glora, try_load_norm, try_load_full, + ), ) diff --git a/pipelines/model_anima.py b/pipelines/model_anima.py index 917b8981c..488b0074a 100644 --- a/pipelines/model_anima.py +++ b/pipelines/model_anima.py @@ -120,8 +120,7 @@ def load_anima(checkpoint_info, diffusers_load_config=None): repo_id, cls_name=transformers.Qwen3Model, load_config=diffusers_load_config, - subfolder="text_encoder", - allow_shared=False + subfolder="text_encoder" ) if llm_adapter is None: diff --git a/pipelines/model_ideogram4.py b/pipelines/model_ideogram4.py index cbb09e5d3..3dcdac0c1 100644 --- a/pipelines/model_ideogram4.py +++ b/pipelines/model_ideogram4.py @@ -1,3 +1,5 @@ +import dataclasses + import diffusers import transformers from modules import shared, devices, sd_models, model_quant, sd_hijack_te, sd_hijack_vae @@ -41,11 +43,16 @@ def load_ideogram4(checkpoint_info, diffusers_load_config=None): if repo_id is None or repo_id.lower() == 'none': return None + from pipelines.ideogram import IDEOGRAM4_SPEC transformer_cls = diffusers.Ideogram4Transformer2DModel - transformer = generic.load_transformer(repo_id, cls_name=transformer_cls, subfolder="transformer", load_config=diffusers_load_config) + transformer = generic.load_transformer(repo_id, cls_name=transformer_cls, subfolder="transformer", load_config=diffusers_load_config, native_spec=IDEOGRAM4_SPEC) if shared.opts.model_ideogram4_enable_cg: - unconditional_transformer = generic.load_transformer(repo_id, cls_name=transformer_cls, subfolder="unconditional_transformer", load_config=diffusers_load_config) + # the spec subfolder swap makes an unconditional override fetch its config from the matching subfolder + unconditional_transformer = generic.load_transformer( + repo_id, cls_name=transformer_cls, subfolder="unconditional_transformer", load_config=diffusers_load_config, + native_spec=dataclasses.replace(IDEOGRAM4_SPEC, subfolder="unconditional_transformer"), override_slot='secondary', + ) else: unconditional_transformer = None text_encoder = generic.load_text_encoder(repo_id, cls_name=transformers.Qwen3VLModel, load_config=diffusers_load_config) diff --git a/pipelines/model_joy.py b/pipelines/model_joy.py index 98086655e..5a305be90 100644 --- a/pipelines/model_joy.py +++ b/pipelines/model_joy.py @@ -5,7 +5,7 @@ from modules.logger import log from pipelines import generic -def load_joy(checkpoint_info, diffusers_load_config=None): +def load_joyedit(checkpoint_info, diffusers_load_config=None): if diffusers_load_config is None: diffusers_load_config = {} repo_id = sd_models.path_to_repo(checkpoint_info) @@ -15,9 +15,13 @@ def load_joy(checkpoint_info, diffusers_load_config=None): log.debug(f'Load model: type=JoyImageEdit repo="{repo_id}" config={diffusers_load_config} offload={shared.opts.diffusers_offload_mode} dtype={devices.dtype} args={load_args}') from pipelines.joy import JOY_SPEC + if 'plus' in repo_id.lower(): + dit_cls = diffusers.JoyImageEditPlusTransformer3DModel + else: + dit_cls = diffusers.JoyImageEditTransformer3DModel transformer = generic.load_transformer( repo_id, - cls_name=diffusers.JoyImageEditTransformer3DModel, + cls_name=dit_cls, load_config=diffusers_load_config, native_spec=JOY_SPEC, ) @@ -29,7 +33,11 @@ def load_joy(checkpoint_info, diffusers_load_config=None): if repo_id is None or repo_id.lower() == 'none': return None - pipe = diffusers.JoyImageEditPipeline.from_pretrained( + if 'plus' in repo_id.lower(): + model_cls = diffusers.JoyImageEditPlusPipeline + else: + model_cls = diffusers.JoyImageEditPipeline + pipe = model_cls.from_pretrained( repo_id, cache_dir=shared.opts.diffusers_dir, transformer=transformer, @@ -40,8 +48,8 @@ def load_joy(checkpoint_info, diffusers_load_config=None): 'output_type': 'np', } - diffusers.pipelines.auto_pipeline.AUTO_TEXT2IMAGE_PIPELINES_MAPPING['joy-image-edit'] = diffusers.JoyImageEditPipeline - diffusers.pipelines.auto_pipeline.AUTO_IMAGE2IMAGE_PIPELINES_MAPPING['joy-image-edit'] = diffusers.JoyImageEditPipeline + diffusers.pipelines.auto_pipeline.AUTO_TEXT2IMAGE_PIPELINES_MAPPING['joy-image-edit'] = model_cls + diffusers.pipelines.auto_pipeline.AUTO_IMAGE2IMAGE_PIPELINES_MAPPING['joy-image-edit'] = model_cls generic.load_vae_override(pipe, diffusers_load_config) diff --git a/pipelines/model_wanai.py b/pipelines/model_wanai.py index 2a7a421ea..9a9a1bdda 100644 --- a/pipelines/model_wanai.py +++ b/pipelines/model_wanai.py @@ -42,7 +42,7 @@ def load_wan(checkpoint_info, diffusers_load_config=None): boundary_ratio = 1000.0 elif shared.opts.model_wan_stage == 'combined' or shared.opts.model_wan_stage == 'both': transformer = generic.load_transformer(repo_id, cls_name=transformer_cls, load_config=diffusers_load_config, subfolder='transformer') - transformer_2 = generic.load_transformer(repo_id, cls_name=transformer_cls, load_config=diffusers_load_config, subfolder='transformer_2') + transformer_2 = generic.load_transformer(repo_id, cls_name=transformer_cls, load_config=diffusers_load_config, subfolder='transformer_2', override_slot='secondary') # load with the checkpoint's boundary; the slider override is applied at runtime in set_pipeline_args boundary_ratio = None else: diff --git a/pipelines/native_transformer.py b/pipelines/native_transformer.py index d04331a74..441c5f1c0 100644 --- a/pipelines/native_transformer.py +++ b/pipelines/native_transformer.py @@ -19,15 +19,19 @@ from diffusers' ``SINGLE_FILE_LOADABLE_CLASSES`` table. Algorithm: 1. Read the safetensors state dict (.gguf and .pth are rejected up front). -2. Detect and strip one of the spec's known prefixes (raises on mixed prefixes). -3. Check forbidden markers (catches structural mismatches like Cosmos 1.0 keys +2. Drop keys belonging to known companion component families (all-in-one + exports bundle the text encoder and VAE under prefixes like + ``cond_stage_model.`` / ``first_stage_model.``; sdnext sources those + components elsewhere). +3. Detect and strip one of the spec's known prefixes (raises on mixed prefixes). +4. Check forbidden markers (catches structural mismatches like Cosmos 1.0 keys in a Cosmos 2.0 loader). -4. Partition off sibling component keys (e.g. Anima's bundled ``llm_adapter.*``). -5. Run the spec's converter if present (else pass through unchanged). -6. Fetch ``/config.json`` from the base repo, instantiate via +5. Partition off sibling component keys (e.g. Anima's bundled ``llm_adapter.*``). +6. Run the spec's converter if present (else pass through unchanged). +7. Fetch ``/config.json`` from the base repo, instantiate via ``cls.from_config``, ``load_state_dict(strict=False)``, validate, dtype-cast, quantize, and offload-place. -7. Repeat the build for each populated sibling (no converter, no quant by +8. Repeat the build for each populated sibling (no converter, no quant by default; sibling weights are read raw from the bundled file). Returns ``(transformer, sibling_components_dict)``. The dict is empty for @@ -37,6 +41,7 @@ loading the adapter from the base repo. """ import os +import json import time from dataclasses import dataclass, field from typing import Callable @@ -58,6 +63,20 @@ DEFAULT_ACCEPTABLE_MISSING: tuple[str, ...] = ( "pos_embedder.", "learnable_pos_embed.", ) +DEFAULT_IGNORED_PREFIXES: tuple[str, ...] = ( + "cond_stage_model.", + "conditioner.", + "first_stage_model.", + "text_encoders.", + "vae.", +) +COMFY_QUANT_MARKER = ".comfy_quant" +COMFY_QUANT_FORMATS: dict[str, str] = { # comfy_quant format string -> SDNQ weights_dtype + "int8_tensorwise": "int8", + "float8_e4m3fn": "float8_e4m3fn", + "nvfp4": "float4_e2m1fn", +} +NVFP4_GROUP_SIZE = 16 # fixed by the format definition; markers restate it class OverrideArchMismatch(Exception): @@ -106,12 +125,23 @@ class TransformerSpec: ``acceptable_missing`` (buffer-only keys left at their init), these are zero-filled on load so the branch stays a no-op, matching a base model that ships the branch dormant (output projection all-zeros). + + ``ignored_prefixes`` names companion component families (text encoder, + VAE) that all-in-one exports bundle alongside the transformer; their keys + are dropped before prefix detection rather than treated as a malformed + file. + + ``converter_handles_quant`` runs the converter before comfy_quant + detection; such converters must translate marker/scale sidecar keys along + with the weights. Float-oriented converters keep the default. """ cls: type subfolder: str = "transformer" prefixes: tuple[str, ...] = DEFAULT_PREFIXES + ignored_prefixes: tuple[str, ...] = DEFAULT_IGNORED_PREFIXES converter: Callable[[dict], dict] | None = None + converter_handles_quant: bool = False siblings: dict[str, SiblingSpec] = field(default_factory=dict) acceptable_missing: tuple[str, ...] = DEFAULT_ACCEPTABLE_MISSING zero_init_missing: tuple[str, ...] = () @@ -246,7 +276,12 @@ def load( quant_type = model_quant.get_quant_type(quant_args) state_dict = sd_models.read_state_dict(local_file, what="transformer") + metadata_layers = read_quantization_metadata(local_file) + state_dict = drop_companion_keys(state_dict, spec.ignored_prefixes, spec.cls.__name__) state_dict, detected_prefix = strip_prefix(state_dict, spec.prefixes, spec.cls.__name__) + if metadata_layers and detected_prefix: + # header metadata names mirror the file's tensor naming, so they carry the same prefix + metadata_layers = {name[len(detected_prefix):] if name.startswith(detected_prefix) else name: meta for name, meta in metadata_layers.items()} check_forbidden_markers(state_dict, spec.forbidden_markers, spec.cls.__name__, local_file) transformer_sd, sibling_sds = partition_siblings(state_dict, spec.siblings) del state_dict @@ -274,6 +309,8 @@ def load( dtype=effective_dtype, modules_to_not_convert=modules_to_not_convert, modules_dtype_dict=modules_dtype_dict, + converter_handles_quant=spec.converter_handles_quant, + metadata_layers=metadata_layers, **kwargs, ) del transformer_sd @@ -309,6 +346,40 @@ def load( return transformer, loaded_siblings +def drop_companion_keys(state_dict: dict, ignored_prefixes: tuple[str, ...], type_name: str) -> dict: + """Remove keys belonging to known non-transformer component families. + + All-in-one exports bundle the text encoder and VAE alongside the + transformer under LDM/ComfyUI-style family prefixes (``cond_stage_model.``, + ``first_stage_model.``, ``text_encoders.``, ``vae.``). Only the transformer + (plus any spec-declared inline siblings) is wanted here; sdnext sources the + other components from the base repo or their own override dropdowns. + Dropped families are logged so the skip is visible in the load log. + + Raises ValueError when nothing remains after filtering, meaning the + selected file holds no transformer at all. + """ + if not ignored_prefixes: + return state_dict + dropped: dict[str, int] = {} + kept: dict = {} + for key, value in state_dict.items(): + prefix = next((p for p in ignored_prefixes if key.startswith(p)), None) + if prefix is None: + kept[key] = value + else: + dropped[prefix] = dropped.get(prefix, 0) + 1 + if not dropped: + return state_dict + counts = " ".join(f"{prefix.rstrip('.')}={count}" for prefix, count in dropped.items()) + if not kept: + raise ValueError( + f"Load model: type={type_name} native_transformer has no transformer keys ({counts})" + ) + log.info(f"Load model: type={type_name} native_transformer skipping bundled components: {counts}") + return kept + + def strip_prefix(state_dict: dict, prefixes: tuple[str, ...], type_name: str) -> tuple[dict, str]: """Detect and uniformly strip the most common known prefix from every key. @@ -363,6 +434,225 @@ def check_forbidden_markers( ) +def read_quantization_metadata(local_file: str) -> dict[str, dict] | None: + """Read per-layer quantization info from the safetensors header metadata. + + Newer comfy_quant checkpoints record layer formats in the header + ``__metadata__`` under ``_quantization_metadata`` (a JSON string with a + ``layers`` map keyed by tensor naming) instead of per-layer marker + tensors. Returns the layers map, or ``None`` when the header carries no + such entry. Raises :class:`OverrideArchMismatch` when the entry is + present but malformed, so the caller's base-repo fallback engages. + """ + from modules.model_probe import read_safetensors_header + try: + header = read_safetensors_header(local_file) + except Exception as e: + log.debug(f'Load model: file="{local_file}" header metadata unreadable ({e})') + return None + meta = (header.get("__metadata__") or {}).get("_quantization_metadata") + if meta is None: + return None + try: + parsed = json.loads(meta) if isinstance(meta, str) else meta + layers = parsed["layers"] + except Exception as e: + raise OverrideArchMismatch( + f'Load model: file="{local_file}" native_transformer _quantization_metadata ' + f"is malformed ({type(e).__name__}: {e})" + ) from e + if not isinstance(layers, dict) or not all(isinstance(entry, dict) for entry in layers.values()): + raise OverrideArchMismatch( + f'Load model: file="{local_file}" native_transformer _quantization_metadata ' + f"layers map is malformed" + ) + return layers + + +def transcode_quant_metadata(state_dict: dict, metadata_layers: dict[str, dict]) -> tuple[dict, str]: + """Synthesize per-layer marker tensors from header quantization metadata. + + Header metadata and marker tensors describe the same per-layer format + dicts; converging on markers lets detection, converters, and remapping + handle both forms identically. Entries without a matching ``.weight`` + (companion components filtered earlier) are skipped; existing markers + are overwritten by their header entry. Returns a new dict plus the + detection source (``header`` or ``both``) for logging. + """ + sd = dict(state_dict) + had_markers = any(key.endswith(COMFY_QUANT_MARKER) for key in sd) + count = 0 + for name, meta in metadata_layers.items(): + if f"{name}.weight" not in sd: + continue + sd[f"{name}{COMFY_QUANT_MARKER}"] = torch.tensor(list(json.dumps(meta).encode("utf-8")), dtype=torch.uint8) + count += 1 + if count == 0: + return state_dict, "markers" + return sd, "both" if had_markers else "header" + + +def detect_comfy_quant(state_dict: dict, type_name: str) -> tuple[dict[str, dict], str] | None: + """Detect ``comfy_quant`` pre-quantized layers in a state dict. + + ComfyUI-format quantized checkpoints mark each quantized layer with a + ``.comfy_quant`` uint8 tensor whose bytes are a JSON object naming + the storage format, alongside a ``.weight_scale`` tensor. Returns + a mapping of marked module names to their parsed marker JSON plus the + file's format string, or ``None`` when no markers are present. ConvRot + markers (``convrot``/``convrot_groupsize``) are accepted per layer: the + rotation is the same regular Hadamard SDNQ implements, so flagged layers + map onto ``use_hadamard`` (regular Hadamards only exist for power-of-4 + group sizes). Raises :class:`OverrideArchMismatch` for + malformed markers, unsupported formats or group sizes, or a file mixing + formats across layers, so the caller's base-repo fallback engages. + """ + marker_keys = [key for key in state_dict if key.endswith(COMFY_QUANT_MARKER)] + if not marker_keys: + return None + marked: dict[str, dict] = {} + formats: set[str] = set() + for key in marker_keys: + name = key[: -len(COMFY_QUANT_MARKER)] + try: + meta = json.loads(state_dict[key].cpu().numpy().tobytes()) + fmt = meta["format"] + except Exception as e: + raise OverrideArchMismatch( + f"Load model: type={type_name} native_transformer comfy_quant marker " + f"for {name!r} is malformed ({type(e).__name__}: {e})" + ) from e + if meta.get("convrot"): + if fmt == "nvfp4": + raise OverrideArchMismatch( + f"Load model: type={type_name} native_transformer comfy_quant layer " + f"{name!r} combines nvfp4 with convrot, which the format does not define" + ) + group_size = int(meta.get("convrot_groupsize", 256)) + is_pow4 = group_size >= 4 and (group_size & (group_size - 1)) == 0 and (group_size.bit_length() & 1) == 1 + if not is_pow4: + raise OverrideArchMismatch( + f"Load model: type={type_name} native_transformer comfy_quant layer " + f"{name!r} convrot_groupsize={group_size} is not a power of 4" + ) + if fmt == "nvfp4" and int(meta.get("group_size", NVFP4_GROUP_SIZE)) != NVFP4_GROUP_SIZE: + raise OverrideArchMismatch( + f"Load model: type={type_name} native_transformer comfy_quant layer " + f"{name!r} nvfp4 group_size={meta.get('group_size')} is not {NVFP4_GROUP_SIZE}" + ) + marked[name] = meta + formats.add(fmt) + unsupported = sorted(formats - set(COMFY_QUANT_FORMATS)) + if unsupported: + log.error( + f'Load model: type={type_name} quant=comfy format={",".join(unsupported)} not supported ' + f'(supported: {",".join(COMFY_QUANT_FORMATS)})' + ) + raise OverrideArchMismatch( + f"Load model: type={type_name} native_transformer comfy_quant format " + f"{', '.join(unsupported)} not supported" + ) + if len(formats) > 1: + raise OverrideArchMismatch( + f"Load model: type={type_name} native_transformer comfy_quant mixes formats " + f"across layers ({', '.join(sorted(formats))})" + ) + return marked, next(iter(formats)) + + +def remap_comfy_quant(state_dict: dict, marked_names: set[str], defer_scales: bool = False) -> dict: + """Translate comfy_quant tensor naming to SDNQ naming. + + Renames ``.weight_scale`` to ``.scale`` (reshaped to 2-D, + ``[]`` becomes ``[1, 1]``, since SDNQ transposes scales in place) and + drops the ``.comfy_quant`` markers plus optional + ``.input_scale`` activation-calibration sidecars (SDNQ re-derives + activation scales dynamically). With ``defer_scales`` the scale rename is + skipped: block-scaled formats (nvfp4) carry swizzled scale tensors whose + transform needs the layer dimensions, so the prequantized builder handles + them per layer. Returns a new dict; the input (which may be the cached + state dict) is not mutated. + """ + scale_suffix = ".weight_scale" + input_scale_suffix = ".input_scale" + remapped: dict = {} + for key, value in state_dict.items(): + if key.endswith(COMFY_QUANT_MARKER) and key[: -len(COMFY_QUANT_MARKER)] in marked_names: + continue + if key.endswith(input_scale_suffix) and key[: -len(input_scale_suffix)] in marked_names: + continue + if not defer_scales and key.endswith(scale_suffix) and key[: -len(scale_suffix)] in marked_names: + remapped[f"{key[: -len(scale_suffix)]}.scale"] = value.reshape(-1, 1) + continue + remapped[key] = value + return remapped + + +def unswizzle_block_scales(scales: torch.Tensor, rows: int, groups: int) -> torch.Tensor: + """Invert the cuBLAS 2D block-scaling factor layout back to row-major + ``[rows, groups]``, dropping the tile alignment padding. + + Block-scaled comfy_quant checkpoints store per-group scales pre-tiled for + the hardware kernels: the ``[roundup(rows, 128), roundup(groups, 4)]`` + grid is rearranged into 32x16 tiles as described in + https://docs.nvidia.com/cuda/cublas/index.html#d-block-scaling-factors-layout + """ + row_blocks = -(rows // -128) + col_blocks = -(groups // -4) + tiles = scales.reshape(-1, 32, 4, 4).transpose(1, 2) + tiles = tiles.reshape(row_blocks, col_blocks, 4, 32, 4).reshape(row_blocks, col_blocks, 128, 4) + return tiles.permute(0, 2, 1, 3).reshape(row_blocks * 128, col_blocks * 4)[:rows, :groups] + + +def adopt_nvfp4_layer(sd: dict, name: str, linear: torch.nn.Linear, component_name: str, meta: dict) -> None: + """Rewrite one nvfp4 layer's tensors in place into SDNQ layout. + + Slices tile-alignment padding off the packed weight, swaps the nibble + order (the container packs the even element into the high nibble, SDNQ + unpacks low-first), unswizzles the e4m3 block scales, and folds the fp32 + global scale into them as ``[out, groups, 1]`` fp32 grouped scales. + """ + out_features, in_features = linear.out_features, linear.in_features + if in_features % NVFP4_GROUP_SIZE != 0: + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant marked module " + f"{name!r} nvfp4 group size {NVFP4_GROUP_SIZE} does not divide in_features={in_features}" + ) + orig_shape = meta.get("orig_shape") + if orig_shape is not None and tuple(orig_shape) != (out_features, in_features): + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant marked module " + f"{name!r} stores orig_shape={tuple(orig_shape)} but the model expects {(out_features, in_features)}" + ) + weight = sd.get(f"{name}.weight") + scales = sd.pop(f"{name}.weight_scale", None) + global_scale = sd.pop(f"{name}.weight_scale_2", None) + if scales is None or global_scale is None: + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant marked module " + f"{name!r} is missing nvfp4 weight_scale/weight_scale_2 tensors" + ) + packed_columns = in_features // 2 + if weight is None or weight.ndim != 2 or weight.shape[0] < out_features or weight.shape[1] < packed_columns: + found = tuple(weight.shape) if weight is not None else "missing" + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant marked module " + f"{name!r} packed weight {found} cannot hold {(out_features, packed_columns)}" + ) + groups = in_features // NVFP4_GROUP_SIZE + expected_scales = -(out_features // -128) * 128 * -(groups // -4) * 4 + if scales.numel() != expected_scales: + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant marked module " + f"{name!r} block scales hold {scales.numel()} values, expected {expected_scales}" + ) + weight = weight[:out_features, :packed_columns] + weight = torch.bitwise_or(torch.bitwise_left_shift(torch.bitwise_and(weight, 15), 4), torch.bitwise_right_shift(weight, 4)) + scales = unswizzle_block_scales(scales, out_features, groups) + sd[f"{name}.weight"] = weight + sd[f"{name}.scale"] = scales.to(torch.float32).mul_(global_scale.to(torch.float32)).unsqueeze(-1) + + def partition_siblings( state_dict: dict, siblings: dict[str, SiblingSpec], @@ -500,6 +790,213 @@ def build_component_quantized( return component +def build_component_prequantized( + *, + component_name: str, + state_dict: dict, + config: dict, + cls: type, + marker_meta: dict[str, dict], + comfy_format: str, + dtype, + acceptable_missing: tuple[str, ...], + zero_init_missing: tuple[str, ...] = (), + **kwargs, +) -> object: + """Build a component from a comfy_quant pre-quantized state dict, mapping + the marked layers onto SDNQ layers without dequantizing. + + The supported formats are subsets of SDNQ's symmetric quantization: same + dequant math (``weight * scale``, no zero point), so tensors are adopted + bit-exact. The 8-bit formats share the storage layout directly (unpacked + ``[out, in]``); convrot layers map onto SDNQ's Hadamard support, whose + identical regular Hadamard construction lets the dequantizer undo the + stored rotation; nvfp4 layers keep their packed 4-bit codes (nibble order + swapped once) and land on SDNQ's grouped quantization with the block and + global scales folded into fp32 per-group scales. + The file dictates which layers are quantized, independent of the user's + quantization settings, and floating-point SDNQ params are not cast to the + target dtype (the fp32 scales must survive). Layers are assembled in + canonical dequant layout; ``apply_sdnq_options_to_model`` then applies + the user's quantized-matmul settings, matching + ``modules.sdnq.loader.load_sdnq_model``. + """ + import rich.progress as rp + from accelerate import init_empty_weights + from accelerate.utils import set_module_tensor_to_device + from diffusers.utils import get_module_from_name + from modules.sdnq.common import dtype_dict, check_torch_compile + from modules.sdnq.kernel_wrappers import is_fp8_compile_supported + from modules.sdnq.quantizer import SDNQConfig, SDNQQuantizer + from modules.sdnq.dequantizer import SDNQDequantizer + from modules.sdnq.layers import get_sdnq_wrapper_class + from modules.sdnq.forward import get_forward_func + from modules.sdnq.loader import apply_sdnq_options_to_model + + weights_dtype = COMFY_QUANT_FORMATS[comfy_format] + matmul_dtype = "int8" if dtype_dict[weights_dtype]["is_integer"] else "float8_e4m3fn" + storage_dtype = dtype_dict[weights_dtype]["storage_dtype"] + target_dtype = dtype if dtype is not None else devices.dtype + is_nvfp4 = comfy_format == "nvfp4" + # on hardware where compiled graphs cannot touch e4m3 tensors, adopt fp8 weights + # through the uint8-backed codec: same values (NaN codes decode as +/-480), and + # compiled dequant beats the eager native-fp8 fallback by ~6x + remap_fp8_storage = weights_dtype == "float8_e4m3fn" and check_torch_compile() and not is_fp8_compile_supported + if remap_fp8_storage: + weights_dtype = "float8_e4m3fn_sdnq" + marked_names = set(marker_meta) + sd = remap_comfy_quant(state_dict, marked_names, defer_scales=is_nvfp4) + + # Civitai relabels these containers freely; trust the marker only as far + # as the stored tensors actually match it. + for name in marked_names: + weight = sd.get(f"{name}.weight") + if weight is None or weight.dtype != storage_dtype: + found = weight.dtype if weight is not None else "missing" + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant format " + f"{comfy_format} expects {storage_dtype} weights but {name!r} has {found}" + ) + if remap_fp8_storage: + sd[f"{name}.weight"] = weight.view(torch.uint8) + + # layers flagged full_precision_matrix_mult stay on the dequant path even + # when the user enables quantized matmul (exact-name match on the config list) + full_precision_mm = [f"{name}.weight" for name in sorted(marked_names) if marker_meta[name].get("full_precision_matrix_mult")] + quantization_config = SDNQConfig( + weights_dtype=weights_dtype, + quantized_matmul_dtype=matmul_dtype, + group_size=NVFP4_GROUP_SIZE if is_nvfp4 else -1, + use_quantized_matmul=shared.opts.sdnq_use_quantized_matmul, + dequantize_fp32=shared.opts.sdnq_dequantize_fp32, + add_skip_keys=False, + modules_to_not_convert=[], + modules_to_not_use_matmul=full_precision_mm, + ) + quantizer = SDNQQuantizer(quantization_config, pre_quantized=True) + quantizer.torch_dtype = target_dtype + + with init_empty_weights(include_buffers=False): + component = cls.from_config(config, **kwargs) + + dequant_forward = get_forward_func("Linear", matmul_dtype, False) + for name in sorted(marked_names): + try: + parent, child = get_module_from_name(component, name) + linear = getattr(parent, child) + except (AttributeError, ValueError) as e: + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant marked " + f"module {name!r} not found in {cls.__name__}" + ) from e + if not isinstance(linear, torch.nn.Linear): + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant marked " + f"module {name!r} is {linear.__class__.__name__}, expected Linear" + ) + # convrot weights are stored rotated by SDNQ's regular Hadamard; the dequantizer undoes it + use_hadamard = bool(marker_meta[name].get("convrot")) + hadamard_group_size = int(marker_meta[name].get("convrot_groupsize", 256)) if use_hadamard else 256 + if use_hadamard and linear.in_features % hadamard_group_size != 0: + raise OverrideArchMismatch( + f"Load model: transformer=native {component_name} comfy_quant marked " + f"module {name!r} convrot_groupsize={hadamard_group_size} does not divide in_features={linear.in_features}" + ) + if is_nvfp4: + adopt_nvfp4_layer(sd, name, linear, component_name, marker_meta[name]) + layer_shape = torch.Size((linear.out_features, linear.in_features)) + linear.sdnq_dequantizer = SDNQDequantizer( + result_dtype=target_dtype, + result_shape=layer_shape if is_nvfp4 else None, + original_shape=layer_shape, + original_stride=(linear.in_features, 1), + quantized_weight_shape=torch.Size((linear.out_features, linear.in_features // NVFP4_GROUP_SIZE, NVFP4_GROUP_SIZE)) if is_nvfp4 else layer_shape, + weights_dtype=weights_dtype, + quantized_matmul_dtype=matmul_dtype, + hadamard_group_size=hadamard_group_size, + group_size=NVFP4_GROUP_SIZE if is_nvfp4 else -1, + svd_rank=32, + svd_steps=8, + use_quantized_matmul=False, + re_quantize_for_matmul=is_nvfp4, + use_stochastic_rounding=False, + use_hadamard=use_hadamard, + layer_class_name="Linear", + ) + wrapped = get_sdnq_wrapper_class(linear, dequant_forward) + wrapped.scale = torch.nn.Parameter(torch.empty((1, 1), dtype=torch.float32, device="meta"), requires_grad=False) + wrapped.zero_point = None + wrapped.svd_up = None + wrapped.svd_down = None + setattr(parent, child, wrapped) + + target_device = ( + devices.cpu if shared.opts.diffusers_offload_mode != "none" + else devices.device + ) + + expected_keys = set(component.state_dict().keys()) + loaded_keys: set[str] = set() + unexpected: list[str] = [] + total = len(sd) + + pbar = rp.Progress( + rp.TextColumn(f'[cyan]Load {component_name}:'), + rp.BarColumn(), + rp.MofNCompleteColumn(), + rp.TaskProgressColumn(), + rp.TimeRemainingColumn(), + rp.TimeElapsedColumn(), + rp.TextColumn('[cyan]{task.description}'), + console=console, + ) + with pbar: + task = pbar.add_task(total=total, description=cls.__name__) + for name, value in sd.items(): + if name in expected_keys: + if quantizer.check_if_quantized_param(component, value, name): + quantizer.create_quantized_param(component, value, name, target_device, dtype=target_dtype) + else: + if torch.is_floating_point(value): + value = value.to(target_dtype) + set_module_tensor_to_device(component, name, target_device, value=value, dtype=target_dtype) + loaded_keys.add(name) + else: + unexpected.append(name) + pbar.update(task, advance=1) + + missing = sorted(expected_keys - loaded_keys) + missing = materialize_zero_init( + component, missing, zero_init_missing, device=target_device, dtype=target_dtype + ) + validate_state_dict_load(component_name, missing, unexpected, acceptable_missing) + + component = quantizer._process_model_after_weight_loading(component) # pylint: disable=protected-access + component = apply_sdnq_options_to_model( + component, + dtype=target_dtype, + dequantize_fp32=shared.opts.sdnq_dequantize_fp32, + use_quantized_matmul=shared.opts.sdnq_use_quantized_matmul, + ) + return component + + +def apply_converter(converter: Callable[[dict], dict], state_dict: dict, cls: type, component_name: str) -> dict: + """Run a spec converter, wrapping any failure as + :class:`OverrideArchMismatch` (with the original chained) so a wrong-arch + file degrades to the base-repo fallback instead of a raw converter crash. + """ + log.debug(f'Load model: transformer=native {component_name} converter={converter.__name__} keys={len(state_dict)}') + try: + return converter(state_dict) + except Exception as e: + raise OverrideArchMismatch( + f"Load model: type={cls.__name__} native_transformer converter " + f"{converter.__name__} rejected the override ({type(e).__name__}: {e}); " + f"file does not look like a {cls.__name__} checkpoint" + ) from e + + def build_component( *, component_name: str, @@ -514,16 +1011,24 @@ def build_component( dtype=None, modules_to_not_convert: list | None = None, modules_dtype_dict: dict | None = None, + converter_handles_quant: bool = False, + metadata_layers: dict[str, dict] | None = None, **kwargs, ) -> object: """Convert (if needed), instantiate, load weights, dtype-cast, quantize, and offload-place a single component. Raises on any hard failure. - For the transformer component under SDNQ, the per-tensor pre-mode path - in :func:`build_component_quantized` is used so quantization is applied - in flight (one layer's worth of bf16 in memory at a time). All other - cases (siblings, non-quantized loads, NVIDIAModelOptConfig, layerwise - quant) go through the standard load_state_dict + post-quantize path. + Transformer state dicts carrying ``comfy_quant`` markers dispatch + to :func:`build_component_prequantized` (``quant_args`` are bypassed: the + file is already quantized). ``metadata_layers`` (header-metadata quant + info) is transcoded into markers first, so both container forms share + one path; a ``converter_handles_quant`` converter runs + before that detection, float-oriented converters after it. Under SDNQ the + transformer uses the per-tensor pre-mode path in + :func:`build_component_quantized` so quantization is applied in flight. + All other cases (siblings, non-quantized loads, NVIDIAModelOptConfig, + layerwise quant) go through the standard load_state_dict + post-quantize + path. ``dtype`` overrides ``devices.dtype`` when supplied; otherwise the global default is used. ``modules_to_not_convert`` and ``modules_dtype_dict`` @@ -532,16 +1037,39 @@ def build_component( reach ``cls.from_config`` for both construction paths. """ try: + quant_source = "markers" + if component_name == "transformer" and metadata_layers: + state_dict, quant_source = transcode_quant_metadata(state_dict, metadata_layers) + + if converter is not None and converter_handles_quant and component_name == "transformer": + state_dict = apply_converter(converter, state_dict, cls, component_name) + converter = None # consumed; must not run again on the non-comfy path below + + comfy_quant = detect_comfy_quant(state_dict, cls.__name__) if component_name == "transformer" else None + if comfy_quant is not None: + marker_meta, comfy_format = comfy_quant + convrot_count = sum(1 for meta in marker_meta.values() if meta.get("convrot")) + log.info( + f'Load model: transformer=native {component_name} quant=comfy ' + f'format={comfy_format} layers={len(marker_meta)} convrot={convrot_count} source={quant_source} keys={len(state_dict)} cls={cls.__name__}' + ) + component = build_component_prequantized( + component_name=component_name, + state_dict=state_dict, + config=config, + cls=cls, + marker_meta=marker_meta, + comfy_format=comfy_format, + dtype=dtype, + acceptable_missing=acceptable_missing, + zero_init_missing=zero_init_missing, + **kwargs, + ) + devices.torch_gc() + return component + if converter is not None: - log.debug(f'Load model: transformer=native {component_name} converter={converter.__name__} keys={len(state_dict)}') - try: - sd = converter(state_dict) - except Exception as e: - raise OverrideArchMismatch( - f"Load model: type={cls.__name__} native_transformer converter " - f"{converter.__name__} rejected the override ({type(e).__name__}: {e}); " - f"file does not look like a {cls.__name__} checkpoint" - ) from e + sd = apply_converter(converter, state_dict, cls, component_name) else: sd = state_dict diff --git a/pipelines/z_image/zimage_lora.py b/pipelines/z_image/zimage_lora.py index 7a3ad7a69..e8c6d7ec4 100644 --- a/pipelines/z_image/zimage_lora.py +++ b/pipelines/z_image/zimage_lora.py @@ -4,12 +4,22 @@ Runs when :func:`modules.lora.lora_overrides.get_method` returns ``'native'`` (``lora_force_diffusers`` off and ``zimage`` in ``allow_native``). Entry points, one per family: :func:`try_load_lora` (plus DoRA), -:func:`try_load_lokr`, :func:`try_load_loha`, :func:`try_load_oft`. +:func:`try_load_lokr`, :func:`try_load_loha`, :func:`try_load_oft`, +:func:`try_load_ia3`, :func:`try_load_glora`, :func:`try_load_norm`, +:func:`try_load_full`. Recognized key prefixes: ``diffusion_model.``, ``transformer.``, ``lora_unet_``, or bare paths starting with the known block-level prefixes (``layers.``, ``noise_refiner.``, ``context_refiner.``). +Checkpoint names that differ from the diffusers module tree are rewritten by +:func:`resolve_targets`: qk-norms (``attention.q_norm`` / ``k_norm`` -> +``attention.norm_q`` / ``norm_k``) and the non-block targets in +``ZIMAGE_EXTRA_MAP`` (``x_embedder`` and ``final_layer.*`` live in ModuleDicts +keyed by ``"{patch_size}-{f_patch_size}"``, read from the live model by +:func:`patch_keys`). ``t_embedder.mlp.N`` and ``cap_embedder.N`` already match +and pass through. + Pre-refactor Z-Image attention layouts (fused ``attention.qkv``, bare ``attention.out`` / ``attention.wo``) are rewritten by :func:`resolve_targets` to the current diffusers ``to_q``/``to_k``/``to_v`` and ``to_out.0``. For @@ -32,6 +42,42 @@ KNOWN_PREFIXES = native_adapter.KNOWN_PREFIXES_DEFAULT BARE_DIFFUSERS_PREFIXES = ("layers.", "noise_refiner.", "context_refiner.") +# Checkpoint qk-norm names vs the diffusers attention module names. +ZIMAGE_NORM_ALIASES = { + ".attention.q_norm": ".attention.norm_q", + ".attention.k_norm": ".attention.norm_k", +} + +# Non-block targets. The patch embedder and the final layer live in ModuleDicts keyed by +# "{patch_size}-{f_patch_size}", so the diffusers path carries a key the checkpoint does not: +# {key} is filled from the live model. t_embedder.mlp.N and cap_embedder.N already match and +# pass through verbatim. +ZIMAGE_EXTRA_MAP = { + "x_embedder": "all_x_embedder.{key}", + "final_layer.linear": "all_final_layer.{key}.linear", + "final_layer.adaLN_modulation.1": "all_final_layer.{key}.adaLN_modulation.1", +} + +ZIMAGE_EXTRA_KOHYA_MAP = {k.replace(".", "_"): v for k, v in ZIMAGE_EXTRA_MAP.items()} + +# Both shipped Z-Image variants (Base, Turbo) build a single entry; read from the live model and +# fall back to it. Tests patch this directly. +PATCH_KEYS_DEFAULT = ["2-1"] + + +def patch_keys(): + """ModuleDict keys of the live transformer's ``all_x_embedder``.""" + try: + from modules import shared + pipe = getattr(shared.sd_model, "pipe", shared.sd_model) + embedder = getattr(getattr(pipe, "transformer", None), "all_x_embedder", None) + keys = list(embedder.keys()) if embedder is not None else [] + if keys: + return keys + except Exception: + pass + return PATCH_KEYS_DEFAULT + # === Re-exports for test/back-compat === @@ -39,11 +85,19 @@ LORA_SUFFIXES = native_adapter.LORA_SUFFIXES LOKR_SUFFIXES = native_adapter.LOKR_SUFFIXES LOHA_SUFFIXES = native_adapter.LOHA_SUFFIXES OFT_SUFFIXES = native_adapter.OFT_SUFFIXES +IA3_SUFFIXES = native_adapter.IA3_SUFFIXES +GLORA_SUFFIXES = native_adapter.GLORA_SUFFIXES +NORM_SUFFIXES = native_adapter.NORM_SUFFIXES +FULL_SUFFIXES = native_adapter.FULL_SUFFIXES LORA_MARKERS = native_adapter.LORA_MARKERS LOKR_MARKERS = native_adapter.LOKR_MARKERS LOHA_MARKERS = native_adapter.LOHA_MARKERS OFT_MARKERS = native_adapter.OFT_MARKERS +IA3_MARKERS = native_adapter.IA3_MARKERS +GLORA_MARKERS = native_adapter.GLORA_MARKERS +NORM_MARKERS = native_adapter.NORM_MARKERS +FULL_MARKERS = native_adapter.FULL_MARKERS SUFFIX_NORMALIZE = native_adapter.SUFFIX_NORMALIZE BARE_DIFFUSERS_PREFIX_USED = native_adapter.BARE_DIFFUSERS_PREFIX_USED @@ -96,6 +150,9 @@ def resolve_targets(prefix_used, base): def _dotted_to_diffusers_targets(base): """For BFL / bare-BFL keys like ``layers.0.attention.qkv``.""" + extra = ZIMAGE_EXTRA_MAP.get(base) + if extra is not None: + return [(extra.format(key=key), None) for key in patch_keys()] if base.endswith(".attention.qkv"): stem = base[:-len(".attention.qkv")] return [ @@ -103,6 +160,9 @@ def _dotted_to_diffusers_targets(base): (f"{stem}.attention.to_k", ChunkSpec(idx=1, total=3)), (f"{stem}.attention.to_v", ChunkSpec(idx=2, total=3)), ] + for alias, renamed in ZIMAGE_NORM_ALIASES.items(): + if base.endswith(alias): + return [(base[:-len(alias)] + renamed, None)] for alias in (".attention.out.0", ".attention.out", ".attention.wo"): if base.endswith(alias): stem = base[:-len(alias)] @@ -112,6 +172,9 @@ def _dotted_to_diffusers_targets(base): def _underscore_to_diffusers_targets(base): """For kohya flat-underscore keys like ``layers_0_attention_qkv``.""" + extra = ZIMAGE_EXTRA_KOHYA_MAP.get(base) + if extra is not None: + return [(extra.format(key=key), None) for key in patch_keys()] if base.endswith("_attention_qkv"): stem = base[:-len("_attention_qkv")] return [ @@ -119,6 +182,10 @@ def _underscore_to_diffusers_targets(base): (f"{stem}_attention_to_k", ChunkSpec(idx=1, total=3)), (f"{stem}_attention_to_v", ChunkSpec(idx=2, total=3)), ] + for alias, renamed in ZIMAGE_NORM_ALIASES.items(): + underscored = alias.replace(".", "_") + if base.endswith(underscored): + return [(base[:-len(underscored)] + renamed.replace(".", "_"), None)] for alias in ("_attention_out_0", "_attention_out", "_attention_wo"): if base.endswith(alias): stem = base[:-len(alias)] @@ -153,9 +220,28 @@ def try_load_oft(name, network_on_disk, lora_scale): return native_adapter.try_load_oft(name, network_on_disk, lora_scale, **_BIND_KWARGS) +def try_load_ia3(name, network_on_disk, lora_scale): + return native_adapter.try_load_ia3(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_glora(name, network_on_disk, lora_scale): + return native_adapter.try_load_glora(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_norm(name, network_on_disk, lora_scale): + return native_adapter.try_load_norm(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + +def try_load_full(name, network_on_disk, lora_scale): + return native_adapter.try_load_full(name, network_on_disk, lora_scale, **_BIND_KWARGS) + + def try_load(name, network_on_disk, lora_scale): """Run every Z-Image family loader, merge any that match.""" return native_adapter.try_load_chain( name, network_on_disk, lora_scale, - family_loaders=(try_load_lora, try_load_lokr, try_load_loha, try_load_oft), + family_loaders=( + try_load_lora, try_load_lokr, try_load_loha, try_load_oft, + try_load_ia3, try_load_glora, try_load_norm, try_load_full, + ), ) diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml new file mode 100644 index 000000000..13c4d5f9b --- /dev/null +++ b/pnpm-workspace.yaml @@ -0,0 +1,8 @@ +allowBuilds: + '@google/genai': false + esbuild: true + protobufjs: false + unrs-resolver: false +packages: + - "extensions-builtin/sdnext-modernui" + - "extensions-builtin/sdnext-kanvas" diff --git a/requirements.txt b/requirements.txt index 2c8bda814..73b5e9ed7 100644 --- a/requirements.txt +++ b/requirements.txt @@ -30,7 +30,7 @@ requests==2.34.2 tqdm==4.68.3 accelerate==1.14.0 einops==0.8.2 -huggingface_hub==1.22.0 +huggingface_hub==1.23.0 hf_xet==1.5.1 numpy==2.1.2 pandas==2.3.1 diff --git a/test/test-chroma-native-adapters.py b/test/test-chroma-native-adapters.py index df8f2238c..696746694 100644 --- a/test/test-chroma-native-adapters.py +++ b/test/test-chroma-native-adapters.py @@ -218,10 +218,24 @@ def build_mock_transformer(): transformer = _Holder() transformer.transformer_blocks = torch.nn.ModuleList([build_double_block() for _ in range(N_DOUBLE)]) transformer.single_transformer_blocks = torch.nn.ModuleList([build_single_block() for _ in range(N_SINGLE)]) - # distilled_guidance_layer - Chroma's central modulation approximator - # Minimal stand-in: just one linear submodule the tests can target + # distilled_guidance_layer - Chroma's central modulation approximator. + # Mirrors ChromaApproximator: in_proj / out_proj Linears, PixArt-shaped + # MLP layers (linear_1 / linear_2) and RMSNorms. transformer.distilled_guidance_layer = _Holder() transformer.distilled_guidance_layer.in_proj = torch.nn.Linear(HIDDEN, HIDDEN, bias=True) + transformer.distilled_guidance_layer.out_proj = torch.nn.Linear(HIDDEN, HIDDEN, bias=True) + transformer.distilled_guidance_layer.layers = torch.nn.ModuleList() + transformer.distilled_guidance_layer.norms = torch.nn.ModuleList() + for _ in range(2): + mlp = _Holder() + mlp.linear_1 = torch.nn.Linear(HIDDEN, HIDDEN, bias=True) + mlp.linear_2 = torch.nn.Linear(HIDDEN, HIDDEN, bias=True) + transformer.distilled_guidance_layer.layers.append(mlp) + transformer.distilled_guidance_layer.norms.append(torch.nn.RMSNorm(HIDDEN)) + # Non-block CHROMA_EXTRA_MAP targets. + transformer.x_embedder = torch.nn.Linear(HIDDEN, HIDDEN) + transformer.context_embedder = torch.nn.Linear(HIDDEN, HIDDEN) + transformer.proj_out = torch.nn.Linear(HIDDEN, HIDDEN, bias=True) return transformer @@ -630,6 +644,32 @@ def test_resolve_targets_static_renames(): return True +def test_resolve_targets_extra_and_guidance(): + """Non-block extra-map renames and guidance-layer MLP leaf renames, all key forms.""" + for bfl_base, diffusers_path in C.CHROMA_EXTRA_MAP.items(): + for prefix, base in [ + ('diffusion_model.', bfl_base), + (None, bfl_base), + ('lora_unet_', bfl_base.replace('.', '_')), + ]: + targets = C.resolve_targets(prefix, base) + assert targets == [(diffusers_path, None)], f'({prefix}, {base}) -> {targets}' + cases = [ + # BFL MLP leaves rename to the PixArt projection names. + (('diffusion_model.', 'distilled_guidance_layer.layers.0.in_layer'), 'distilled_guidance_layer.layers.0.linear_1'), + ((None, 'distilled_guidance_layer.layers.1.out_layer'), 'distilled_guidance_layer.layers.1.linear_2'), + (('lora_unet_', 'distilled_guidance_layer_layers_0_in_layer'), 'distilled_guidance_layer_layers_0_linear_1'), + (('lora_unet_', 'distilled_guidance_layer_layers_1_out_layer'), 'distilled_guidance_layer_layers_1_linear_2'), + # Verbatim leaves are untouched in either naming. + (('diffusion_model.', 'distilled_guidance_layer.in_proj'), 'distilled_guidance_layer.in_proj'), + ((None, 'distilled_guidance_layer.layers.0.linear_1'), 'distilled_guidance_layer.layers.0.linear_1'), + ] + for (prefix, base), expected in cases: + targets = C.resolve_targets(prefix, base) + assert targets == [(expected, None)], f'({prefix}, {base}) -> {targets}' + return True + + def test_resolve_targets_onetrainer_passthrough(): """The ``lora_transformer_`` passthrough lives in the shared resolver. @@ -805,6 +845,60 @@ def test_lora_distilled_guidance(): return True +def sd_lokr_bfl_extra_modules(): + """BFL LoKR spanning the non-block extra targets and guidance MLP leaves. + + Full-matrix factors with the ai-toolkit placeholder alpha, mirroring the + layout of real full-preset checkpoints. + """ + bases = [ + 'img_in', 'txt_in', 'final_layer.linear', + 'distilled_guidance_layer.layers.0.in_layer', + 'distilled_guidance_layer.layers.1.out_layer', + ] + sd = {} + for base in bases: + sd[f'diffusion_model.{base}.lokr_w1'] = torch.randn(LOKR_W1_DIM, LOKR_W1_DIM) + sd[f'diffusion_model.{base}.lokr_w2'] = torch.randn(HIDDEN // LOKR_W1_DIM, HIDDEN // LOKR_W1_DIM) + sd[f'diffusion_model.{base}.alpha'] = torch.tensor(9999220736.0) + return sd + + +def test_lokr_bfl_extra_and_guidance(): + """Embedder/final-layer renames and guidance MLP leaf renames all bind.""" + net = _load_via(C.try_load_lokr, sd_lokr_bfl_extra_modules()) + assert net is not None and len(net.modules) == 5, f'got {sorted(net.modules) if net else None}' + expected = { + 'lora_transformer_x_embedder', + 'lora_transformer_context_embedder', + 'lora_transformer_proj_out', + 'lora_transformer_distilled_guidance_layer_layers_0_linear_1', + 'lora_transformer_distilled_guidance_layer_layers_1_linear_2', + } + assert set(net.modules) == expected, f'got {set(net.modules)}' + # Full-matrix factors: the placeholder alpha must not scale. + for nk, mod in net.modules.items(): + assert mod.dim is None and mod.calc_scale() == 1.0, f'{nk}: dim={mod.dim} scale={mod.calc_scale()}' + return True + + +def test_full_diff_chain(): + """Full-diff extraction loads through the chain; fused qkv diff skips.""" + sd = { + 'diffusion_model.double_blocks.0.img_attn.proj.diff': torch.randn(HIDDEN, HIDDEN), + 'diffusion_model.double_blocks.0.img_attn.proj.diff_b': torch.randn(HIDDEN), + 'diffusion_model.double_blocks.0.img_attn.qkv.diff': torch.randn(3 * HIDDEN, HIDDEN), + } + net = _load_via(C.try_load, sd) + assert net is not None and len(net.modules) == 1, f'got {net.modules if net else None}' + assert 'lora_transformer_transformer_blocks_0_attn_to_out_0' in net.modules, f'got {set(net.modules)}' + mod = next(iter(net.modules.values())) + updown, ex_bias = mod.calc_updown(mod.sd_module.weight) + assert tuple(updown.shape) == (HIDDEN, HIDDEN) and torch.isfinite(updown).all() + assert ex_bias is not None and tuple(ex_bias.shape) == (HIDDEN,) + return True + + def test_lora_dora_threading(): """dora_scale flows into NetworkModuleLora.""" net = _load_via(C.try_load_lora, sd_lora_with_dora_scale()) @@ -979,6 +1073,7 @@ def run_tests(): log.warning('=== Parsing primitives ===') for fn in [test_parse_key_all_prefixes, test_marker_disambiguation, test_resolve_targets_static_renames, + test_resolve_targets_extra_and_guidance, test_resolve_targets_onetrainer_passthrough]: run_test(CAT_PARSE, fn) @@ -1000,6 +1095,8 @@ def run_tests(): test_lokr_bfl_img_attn_proj, test_lokr_bfl_img_attn_qkv_chunked, test_lokr_bfl_single_linear1_unequal_chunks, + test_lokr_bfl_extra_and_guidance, + test_full_diff_chain, test_loha_bfl_img_attn_proj, test_loha_bfl_img_attn_qkv_chunked, test_oft_bfl_img_attn_proj, diff --git a/test/test-ernie-native-adapters.py b/test/test-ernie-native-adapters.py index 84447694a..db32c1719 100644 --- a/test/test-ernie-native-adapters.py +++ b/test/test-ernie-native-adapters.py @@ -565,6 +565,22 @@ def test_oft_lycoris_no_npe(): return True +def test_full_diff_chain(): + """Full-diff extraction loads through the chain (ERNIE has no fused targets).""" + sd = { + 'diffusion_model.layers.0.self_attention.to_q.diff': torch.randn(HIDDEN, HIDDEN), + 'diffusion_model.layers.0.self_attention.to_q.diff_b': torch.randn(HIDDEN), + } + net = _load_via(E.try_load, sd) + assert net is not None and len(net.modules) == 1, f'got {net.modules if net else None}' + assert 'lora_transformer_layers_0_self_attention_to_q' in net.modules, f'got {set(net.modules)}' + mod = next(iter(net.modules.values())) + updown, ex_bias = mod.calc_updown(mod.sd_module.weight) + assert tuple(updown.shape) == (HIDDEN, HIDDEN) and torch.isfinite(updown).all() + assert ex_bias is not None and tuple(ex_bias.shape) == (HIDDEN,) + return True + + # ============================================================ # Tests - calc_updown shape sanity # ============================================================ @@ -635,6 +651,7 @@ def run_tests(): test_lokr_bfl_self_attention, test_loha_bfl_mlp, test_oft_lycoris_no_npe, + test_full_diff_chain, ]: run_test(CAT_LOADER, fn) diff --git a/test/test-flux2-native-adapters.py b/test/test-flux2-native-adapters.py index be755e724..1375e25a1 100644 --- a/test/test-flux2-native-adapters.py +++ b/test/test-flux2-native-adapters.py @@ -128,9 +128,10 @@ class _Holder(torch.nn.Module): def build_mock_transformer(): """Build a torch.nn.Module mimicking Flux2's diffusers-side module tree. - Mirrors the paths in F2_SINGLE_MAP / F2_DOUBLE_MAP / F2_QKV_MAP plus the - RMSNorm targets inside attention so that try_load_norm has something to - bind. Sizes are scaled-down but proportional so chunking math is realistic. + Mirrors the paths in F2_SINGLE_MAP / F2_DOUBLE_MAP / F2_QKV_MAP / + F2_EXTRA_MAP plus the RMSNorm targets inside attention so that + try_load_norm has something to bind. Sizes are scaled-down but + proportional so chunking math is realistic. """ transformer = _Holder() transformer.transformer_blocks = torch.nn.ModuleList() @@ -163,6 +164,26 @@ def build_mock_transformer(): sblock.attn.to_qkv_mlp_proj = torch.nn.Linear(HIDDEN, SINGLE_FUSED_OUT, bias=False) sblock.attn.to_out = torch.nn.Linear(SINGLE_OUT_IN, HIDDEN, bias=False) transformer.single_transformer_blocks.append(sblock) + # Non-block F2_EXTRA_MAP targets. Modulation/norm_out out-dims follow the + # real modules' expansion ratios (3x/6x per mod_param_sets, 2x for AdaLN). + transformer.x_embedder = torch.nn.Linear(HIDDEN, HIDDEN, bias=False) + transformer.context_embedder = torch.nn.Linear(HIDDEN, HIDDEN, bias=False) + transformer.time_guidance_embed = _Holder() + transformer.time_guidance_embed.timestep_embedder = _Holder() + transformer.time_guidance_embed.timestep_embedder.linear_1 = torch.nn.Linear(HIDDEN, HIDDEN, bias=False) + transformer.time_guidance_embed.timestep_embedder.linear_2 = torch.nn.Linear(HIDDEN, HIDDEN, bias=False) + transformer.time_guidance_embed.guidance_embedder = _Holder() + transformer.time_guidance_embed.guidance_embedder.linear_1 = torch.nn.Linear(HIDDEN, HIDDEN, bias=False) + transformer.time_guidance_embed.guidance_embedder.linear_2 = torch.nn.Linear(HIDDEN, HIDDEN, bias=False) + transformer.norm_out = _Holder() + transformer.norm_out.linear = torch.nn.Linear(HIDDEN, 2 * HIDDEN, bias=False) + transformer.proj_out = torch.nn.Linear(HIDDEN, HIDDEN, bias=False) + transformer.single_stream_modulation = _Holder() + transformer.single_stream_modulation.linear = torch.nn.Linear(HIDDEN, 3 * HIDDEN, bias=False) + transformer.double_stream_modulation_img = _Holder() + transformer.double_stream_modulation_img.linear = torch.nn.Linear(HIDDEN, 6 * HIDDEN, bias=False) + transformer.double_stream_modulation_txt = _Holder() + transformer.double_stream_modulation_txt.linear = torch.nn.Linear(HIDDEN, 6 * HIDDEN, bias=False) return transformer @@ -308,6 +329,56 @@ def sd_lora_with_dora_scale(): } +def sd_lora_dora_fused_qkv(): + """Kohya LoRA on fused img_attn.qkv with per-output dora_scale (LyCORIS wd_on_out=True).""" + return { + 'lora_unet_double_blocks_0_img_attn_qkv.lora_down.weight': torch.randn(RANK_LORA, HIDDEN), + 'lora_unet_double_blocks_0_img_attn_qkv.lora_up.weight': torch.randn(3 * QKV_OUT, RANK_LORA), + 'lora_unet_double_blocks_0_img_attn_qkv.alpha': torch.tensor(float(RANK_LORA)), + 'lora_unet_double_blocks_0_img_attn_qkv.dora_scale': torch.rand(3 * QKV_OUT, 1) + 0.5, + } + + +def sd_lora_diff_b_fused_qkv(): + """Kohya LoRA on fused img_attn.qkv with a per-output diff_b bias delta.""" + sd = dict(sd_lora_dora_fused_qkv()) + del sd['lora_unet_double_blocks_0_img_attn_qkv.dora_scale'] + sd['lora_unet_double_blocks_0_img_attn_qkv.diff_b'] = torch.randn(3 * QKV_OUT) + return sd + + +def sd_lora_aitk_magnitude_dora(w_base): + """ai-toolkit DoRA save: lora_A/B + 1-D magnitude row norms, no alpha key. + + Targets img_attn.proj -> attn.to_out.0, a square Linear (HIDDEN == QKV_OUT + in the mock): the case where a raw 1-D vector cannot be disambiguated + between per-output and per-input at apply time. + """ + down = torch.randn(RANK_LORA, QKV_OUT) + up = torch.randn(HIDDEN, RANK_LORA) + magnitude = w_base.reshape(HIDDEN, -1).norm(dim=1) # 1-D (out,) + return { + 'diffusion_model.double_blocks.1.img_attn.proj.lora_A.weight': down, + 'diffusion_model.double_blocks.1.img_attn.proj.lora_B.weight': up, + 'diffusion_model.double_blocks.1.img_attn.proj.magnitude': magnitude, + }, down, up, magnitude + + +def sd_lokr_dora_fused_qkv(per_input=False): + """Kohya LoKR on fused img_attn.qkv with a dora_scale companion. + + ``per_input=True`` stores the wd_on_out=False orientation ``(1, in)``, + which has no exact per-chunk split and must be skipped by the loader. + """ + sd = dict(sd_lokr_kohya_qkv()) + if per_input: + ds = torch.rand(1, HIDDEN) + 0.5 + else: + ds = torch.rand(3 * QKV_OUT, 1) + 0.5 + sd['lora_unet_double_blocks_0_img_attn_qkv.dora_scale'] = ds + return sd + + def sd_lokr_bfl_proj(): """BFL-format LoKR on a non-fused proj target.""" return { @@ -361,6 +432,35 @@ def sd_lokr_simpletuner_lycoris_style(): } +def sd_lokr_bfl_extra_modules(): + """BFL-format LoKR spanning every non-block target in F2_EXTRA_MAP. + + Mirrors the ai-toolkit full-matrix layout (klein_snofs_v1_1): both factors + stored whole (lokr_w1/lokr_w2, no a/b decomposition) with the ~1e10 + placeholder alpha. With no rank-decomposed factor the loader must leave + dim=None so the placeholder never scales the delta. + """ + dims = { + 'img_in': (HIDDEN, HIDDEN), + 'txt_in': (HIDDEN, HIDDEN), + 'time_in.in_layer': (HIDDEN, HIDDEN), + 'time_in.out_layer': (HIDDEN, HIDDEN), + 'guidance_in.in_layer': (HIDDEN, HIDDEN), + 'guidance_in.out_layer': (HIDDEN, HIDDEN), + 'final_layer.linear': (HIDDEN, HIDDEN), + 'final_layer.adaLN_modulation.1': (2 * HIDDEN, HIDDEN), + 'single_stream_modulation.lin': (3 * HIDDEN, HIDDEN), + 'double_stream_modulation_img.lin': (6 * HIDDEN, HIDDEN), + 'double_stream_modulation_txt.lin': (6 * HIDDEN, HIDDEN), + } + sd = {} + for base, (out_dim, in_dim) in dims.items(): + sd[f'diffusion_model.{base}.lokr_w1'] = torch.randn(LOKR_W1_DIM, LOKR_W1_DIM) + sd[f'diffusion_model.{base}.lokr_w2'] = torch.randn(out_dim // LOKR_W1_DIM, in_dim // LOKR_W1_DIM) + sd[f'diffusion_model.{base}.alpha'] = torch.tensor(9999220736.0) + return sd + + def sd_loha_bfl_proj(): """BFL-format LoHA on a non-fused proj target.""" return { @@ -607,6 +707,21 @@ def test_resolve_targets_qkv_chunking(): return True +def test_resolve_targets_extra_modules(): + """Every non-block F2_EXTRA_MAP target maps 1:1 (no chunk) in all three key forms.""" + for bfl_base, diffusers_path in F.F2_EXTRA_MAP.items(): + targets = F.resolve_targets('diffusion_model.', bfl_base) + assert targets == [(diffusers_path, None)], f'{bfl_base} -> {targets}' + targets = F.resolve_targets(None, bfl_base) + assert targets == [(diffusers_path, None)], f'bare {bfl_base} -> {targets}' + targets = F.resolve_targets('lora_unet_', bfl_base.replace('.', '_')) + assert targets == [(diffusers_path, None)], f'kohya {bfl_base} -> {targets}' + # guidance_in is a bare BFL prefix in its own right. + got = F.parse_key('guidance_in.in_layer.lora_A.weight', F.LORA_SUFFIXES) + assert got == (None, 'guidance_in.in_layer', 'lora_down.weight'), f'bare guidance_in parse -> {got}' + return True + + def test_parse_key_peft_wrapper_unwrap(): """base_model.model. wrapper is stripped before format detection. @@ -653,8 +768,9 @@ def test_parse_key_lycoris_prefix(): got = F.parse_key(key, suffixes) assert got == expected, f'parse_key({key!r}) = {got}, expected {expected}' - # resolve_targets: the underscored path is returned verbatim (no chunk). - targets = F.resolve_targets('lycoris_', 'transformer_blocks_0_attn_add_k_proj') + # Resolution: lycoris_ is a universal passthrough handled upstream of the + # arch resolver, so the underscored path is returned verbatim (no chunk). + targets = F.native_adapter.resolve_group_targets(F.resolve_targets, 'lycoris_', 'transformer_blocks_0_attn_add_k_proj') assert targets == [('transformer_blocks_0_attn_add_k_proj', None)], f'targets={targets}' return True @@ -846,6 +962,185 @@ def test_lora_dora_threading(): return True +def test_lora_dora_fused_qkv_sliced(): + """Per-output dora_scale is sliced with the up-weight chunk and applies cleanly.""" + net = _load_via(F.try_load_lora, sd_lora_dora_fused_qkv()) + assert net is not None and len(net.modules) == 3, f'got {net.modules if net else None}' + for nk, mod in net.modules.items(): + assert mod.dora_scale is not None and mod.dora_scale.shape[0] == QKV_OUT, \ + f'{nk}: dora_scale shape {tuple(mod.dora_scale.shape) if mod.dora_scale is not None else None}' + updown, _ex_bias = mod.calc_updown(mod.sd_module.weight) + assert_shape(updown, mod.sd_module.weight.shape, label=nk) + assert_finite(updown, label=nk) + return True + + +def test_lokr_dora_fused_qkv_sliced(): + """Per-output dora_scale rides the kron chunk; each module sees its own rows.""" + net = _load_via(F.try_load_lokr, sd_lokr_dora_fused_qkv()) + assert net is not None and len(net.modules) == 3, f'got {net.modules if net else None}' + for nk, mod in net.modules.items(): + assert isinstance(mod, network_lokr.NetworkModuleLokrChunk), f'{nk}: type={type(mod).__name__}' + assert mod.dora_scale is not None and mod.dora_scale.shape[0] == QKV_OUT, \ + f'{nk}: dora_scale shape {tuple(mod.dora_scale.shape) if mod.dora_scale is not None else None}' + updown, _ex_bias = mod.calc_updown(mod.sd_module.weight) + assert_shape(updown, mod.sd_module.weight.shape, label=nk) + assert_finite(updown, label=nk) + return True + + +def test_dora_per_input_fused_skipped(): + """wd_on_out=False dora_scale on a fused target cannot be split; the group is skipped.""" + net = _load_via(F.try_load_lokr, sd_lokr_dora_fused_qkv(per_input=True)) + assert net is None, f'expected no modules, got {net.modules if net else None}' + return True + + +def test_lora_diff_b_fused_qkv_sliced(): + """Per-output diff_b slices with the chunk and flows out as ex_bias.""" + net = _load_via(F.try_load_lora, sd_lora_diff_b_fused_qkv()) + assert net is not None and len(net.modules) == 3, f'got {net.modules if net else None}' + for nk, mod in net.modules.items(): + assert mod.ex_bias is not None and mod.ex_bias.shape[0] == QKV_OUT, \ + f'{nk}: ex_bias shape {tuple(mod.ex_bias.shape) if mod.ex_bias is not None else None}' + _updown, ex_bias = mod.calc_updown(mod.sd_module.weight) + assert ex_bias is not None and ex_bias.shape[0] == QKV_OUT, f'{nk}: applied ex_bias {ex_bias.shape if ex_bias is not None else None}' + return True + + +def test_legacy_bias_fused_skipped(): + """The legacy weight-shaped bias key has no partition on fused targets; group skipped.""" + sd = dict(sd_lora_dora_fused_qkv()) + del sd['lora_unet_double_blocks_0_img_attn_qkv.dora_scale'] + sd['lora_unet_double_blocks_0_img_attn_qkv.bias'] = torch.randn(3 * QKV_OUT, HIDDEN) + net = _load_via(F.try_load_lora, sd) + assert net is None, f'expected skip, got {net.modules if net else None}' + return True + + +def test_lora_aitk_magnitude_dora(): + """ai-toolkit `magnitude` converts onto the dora_scale path, (out, 1)-shaped. + + Numeric check on a square layer: with the raw 1-D vector the apply-time + orientation detection would fall to per-input and renormalize columns; + the (out, 1) reshape pins per-output. Reference: (W+D) * m/||W+D||_row - W + at scale 1 (ai-toolkit DoRA saves no alpha key). + """ + torch.manual_seed(0) + w_base = torch.randn(HIDDEN, QKV_OUT) + sd, down, up, magnitude = sd_lora_aitk_magnitude_dora(w_base) + net = _load_via(F.try_load_lora, sd) + assert net is not None and len(net.modules) == 1, f'got {net.modules if net else None}' + mod = next(iter(net.modules.values())) + assert mod.dora_scale is not None and tuple(mod.dora_scale.shape) == (HIDDEN, 1), \ + f'dora_scale shape {tuple(mod.dora_scale.shape) if mod.dora_scale is not None else None}' + updown, _ex_bias = mod.calc_updown(w_base.clone()) + merged = w_base + up @ down + norm = merged.reshape(HIDDEN, -1).norm(dim=1).reshape(HIDDEN, 1) + torch.finfo(w_base.dtype).eps + ref = merged * (magnitude.reshape(HIDDEN, 1) / norm) - w_base + rel = ((updown - ref).norm() / (ref.norm() + 1e-12)).item() + assert torch.allclose(updown, ref, rtol=1e-4, atol=1e-5), f'rel err {rel:.4f}' + return True + + +def test_lora_magnitude_fused_qkv_sliced(): + """A fused-qkv magnitude vector converts, reshapes and slices per chunk.""" + sd = dict(sd_lora_dora_fused_qkv()) + del sd['lora_unet_double_blocks_0_img_attn_qkv.dora_scale'] + sd['lora_unet_double_blocks_0_img_attn_qkv.magnitude'] = torch.rand(3 * QKV_OUT) + 0.5 + net = _load_via(F.try_load_lora, sd) + assert net is not None and len(net.modules) == 3, f'got {net.modules if net else None}' + for nk, mod in net.modules.items(): + assert mod.dora_scale is not None and tuple(mod.dora_scale.shape) == (QKV_OUT, 1), \ + f'{nk}: dora_scale shape {tuple(mod.dora_scale.shape) if mod.dora_scale is not None else None}' + return True + + +def test_lora_peft_magnitude_vector(): + """PEFT/diffusers `lora_magnitude_vector` converts the same way.""" + sd = { + 'transformer.transformer_blocks.0.attn.to_q.lora_A.weight': torch.randn(RANK_LORA, HIDDEN), + 'transformer.transformer_blocks.0.attn.to_q.lora_B.weight': torch.randn(QKV_OUT, RANK_LORA), + 'transformer.transformer_blocks.0.attn.to_q.lora_magnitude_vector': torch.rand(QKV_OUT) + 0.5, + } + net = _load_via(F.try_load_lora, sd) + assert net is not None and len(net.modules) == 1, f'got {net.modules if net else None}' + mod = next(iter(net.modules.values())) + assert mod.dora_scale is not None and tuple(mod.dora_scale.shape) == (QKV_OUT, 1), \ + f'dora_scale shape {tuple(mod.dora_scale.shape) if mod.dora_scale is not None else None}' + return True + + +def test_lora_sparse_bias_residual(): + """LyCORIS use_bias extraction triplet reconstructs into the dense-bias path. + + Mirrors the extraction save exactly: residual sparsified COO with int16 + indices, values from the weight-shaped remainder, alpha == rank (scale 1). + Reference: total delta = up @ down + residual. + """ + torch.manual_seed(0) + down = torch.randn(RANK_LORA, QKV_OUT) + up = torch.randn(HIDDEN, RANK_LORA) + residual = torch.randn(HIDDEN, QKV_OUT) + residual[torch.rand_like(residual) < 0.98] = 0.0 # extraction sparsity default + sparse = residual.to_sparse().coalesce() + sd = { + 'diffusion_model.double_blocks.1.img_attn.proj.lora_A.weight': down, + 'diffusion_model.double_blocks.1.img_attn.proj.lora_B.weight': up, + 'diffusion_model.double_blocks.1.img_attn.proj.alpha': torch.tensor(float(RANK_LORA)), + 'diffusion_model.double_blocks.1.img_attn.proj.bias_indices': sparse.indices().to(torch.int16), + 'diffusion_model.double_blocks.1.img_attn.proj.bias_values': sparse.values(), + 'diffusion_model.double_blocks.1.img_attn.proj.bias_size': torch.tensor(residual.shape).to(torch.int16), + } + net = _load_via(F.try_load_lora, sd) + assert net is not None and len(net.modules) == 1, f'got {net.modules if net else None}' + mod = next(iter(net.modules.values())) + assert mod.bias is not None and mod.bias.is_sparse, f'bias={type(mod.bias)}' + w_base = torch.randn(HIDDEN, QKV_OUT) + updown, _ex_bias = mod.calc_updown(w_base) + ref = up @ down + residual + rel = ((updown - ref).norm() / (ref.norm() + 1e-12)).item() + assert torch.allclose(updown, ref, rtol=1e-4, atol=1e-5), f'rel err {rel:.4f}' + return True + + +def test_lora_sparse_bias_fused_skipped(): + """The sparse residual triplet on a fused target is skipped like dense bias.""" + sd = dict(sd_lora_kohya_qkv()) + residual = torch.zeros(3 * QKV_OUT, HIDDEN) + residual[0, 0] = 1.0 + sparse = residual.to_sparse().coalesce() + base = 'lora_unet_double_blocks_0_img_attn_qkv' + sd[f'{base}.bias_indices'] = sparse.indices().to(torch.int16) + sd[f'{base}.bias_values'] = sparse.values() + sd[f'{base}.bias_size'] = torch.tensor(residual.shape).to(torch.int16) + net = _load_via(F.try_load_lora, sd) + assert net is None, f'expected skip, got {net.modules if net else None}' + return True + + +def test_lokr_shape_mismatch_rejected(): + """Kron dims that disagree with the module are rejected at load, not at apply.""" + sd = sd_lokr_bfl_proj() + # Double the w2 in-dim: kron becomes (QKV_OUT, 2*HIDDEN) vs module (HIDDEN, QKV_OUT). + sd['diffusion_model.double_blocks.1.img_attn.proj.lokr_w2'] = \ + torch.randn(QKV_OUT // LOKR_W1_DIM, 2 * (HIDDEN // LOKR_W1_DIM)) + net = _load_via(F.try_load_lokr, sd) + assert net is None, f'expected mismatch rejection, got {net.modules if net else None}' + return True + + +def test_lokr_fused_shape_mismatch_rejected(): + """Fused kron rows must cover total*out; a 2-of-3 sized fused delta is rejected.""" + sd = dict(sd_lokr_kohya_qkv()) + # Kron rows 2*QKV_OUT instead of 3*QKV_OUT: no valid 3-way equal chunk. + sd['lora_unet_double_blocks_0_img_attn_qkv.lokr_w2'] = \ + torch.randn((2 * QKV_OUT) // 8, HIDDEN // 4) + net = _load_via(F.try_load_lokr, sd) + assert net is None, f'expected mismatch rejection, got {net.modules if net else None}' + return True + + def test_lokr_bfl_non_fused(): net = _load_via(F.try_load_lokr, sd_lokr_bfl_proj()) assert net is not None and len(net.modules) == 1 @@ -884,6 +1179,28 @@ def test_lokr_simpletuner_lycoris_format(): return True +def test_lokr_bfl_extra_modules_full_matrix(): + """All non-block F2_EXTRA_MAP targets bind; placeholder alpha never scales. + + Regression for the gap where resolve_targets only knew single_blocks / + double_blocks and silently dropped embedder / modulation / final-layer + groups as unmapped. + """ + net = _load_via(F.try_load_lokr, sd_lokr_bfl_extra_modules()) + bound = len(net.modules) if net else 0 + assert net is not None and bound == len(F.F2_EXTRA_MAP), \ + f'bound {bound}/{len(F.F2_EXTRA_MAP)}: {sorted(net.modules) if net else []}' + for nk, mod in net.modules.items(): + assert isinstance(mod, network_lokr.NetworkModuleLokr) and not isinstance(mod, network_lokr.NetworkModuleLokrChunk), \ + f'{nk}: type={type(mod).__name__}' + # Full-matrix factors leave dim unset; the ~1e10 placeholder alpha must be ignored. + assert mod.dim is None and mod.calc_scale() == 1.0, f'{nk}: dim={mod.dim} scale={mod.calc_scale()}' + updown, _ex_bias = mod.calc_updown(mod.sd_module.weight) + assert_shape(updown, mod.sd_module.weight.shape, label=nk) + assert_finite(updown, label=nk) + return True + + def test_loha_bfl_non_fused(): net = _load_via(F.try_load_loha, sd_loha_bfl_proj()) assert net is not None and len(net.modules) == 1 @@ -1156,6 +1473,45 @@ def test_full_calc_updown_shape(): return True +def test_dora_ordering_matches_lycoris(): + """DoRA merge equals the LyCORIS forward reference at multiplier 1 and + lerps the full merged delta at other multipliers (ComfyUI semantics). + + Reference mirrors lycoris locon forward + apply_weight_decompose with + wd_on_out=True: alpha/rank scales the diff BEFORE the row norms. Uses + alpha != rank (the kohya-style case the old decompose-before-scale + ordering got ~64% wrong). + """ + torch.manual_seed(0) + alpha = 1.0 + w_base = torch.randn(QKV_OUT, HIDDEN) + down = torch.randn(RANK_LORA, HIDDEN) + up = torch.randn(QKV_OUT, RANK_LORA) + dora = w_base.reshape(QKV_OUT, -1).norm(dim=1, keepdim=True) + + def reference_delta(mult): + diff = (up @ down) * (alpha / RANK_LORA) + merged = w_base + diff + norm = merged.reshape(QKV_OUT, -1).norm(dim=1).reshape(QKV_OUT, 1) + torch.finfo(w_base.dtype).eps + return (merged * (dora / norm) - w_base) * mult + + sd = { + 'transformer.transformer_blocks.0.attn.to_q.lora_A.weight': down, + 'transformer.transformer_blocks.0.attn.to_q.lora_B.weight': up, + 'transformer.transformer_blocks.0.attn.to_q.alpha': torch.tensor(alpha), + 'transformer.transformer_blocks.0.attn.to_q.dora_scale': dora, + } + for mult in (1.0, 0.5): + net = _load_via(F.try_load_lora, sd) + assert net is not None and len(net.modules) == 1 + mod = make_network_for_module(next(iter(net.modules.values())), te_mul=mult, unet_mul=mult) + updown, _ex_bias = mod.calc_updown(w_base.clone()) + ref = reference_delta(mult) + rel = ((updown - ref).norm() / (ref.norm() + 1e-12)).item() + assert torch.allclose(updown, ref, rtol=1e-4, atol=1e-5), f'mult={mult}: rel err {rel:.4f}' + return True + + # ============================================================ # Tests — apply path / regressions in shared infra # ============================================================ @@ -1227,6 +1583,7 @@ def run_tests(): log.warning('=== Parsing primitives ===') for fn in [test_parse_key_all_prefixes, test_resolve_targets_qkv_chunking, + test_resolve_targets_extra_modules, test_parse_key_peft_wrapper_unwrap, test_parse_key_lycoris_prefix, test_parse_key_bare_diffusers_and_peft_default, test_marker_disambiguation]: @@ -1243,9 +1600,22 @@ def run_tests(): test_lora_peft_saved_dreambooth_style, test_lora_peft_saved_diffusers_style, test_lora_dora_threading, + test_lora_dora_fused_qkv_sliced, + test_lokr_dora_fused_qkv_sliced, + test_dora_per_input_fused_skipped, + test_lora_diff_b_fused_qkv_sliced, + test_legacy_bias_fused_skipped, + test_lora_aitk_magnitude_dora, + test_lora_magnitude_fused_qkv_sliced, + test_lora_peft_magnitude_vector, + test_lora_sparse_bias_residual, + test_lora_sparse_bias_fused_skipped, + test_lokr_shape_mismatch_rejected, + test_lokr_fused_shape_mismatch_rejected, test_lokr_bfl_non_fused, test_lokr_kohya_fused_qkv_chunked, test_lokr_simpletuner_lycoris_format, + test_lokr_bfl_extra_modules_full_matrix, test_loha_bfl_non_fused, test_loha_kohya_fused_qkv_chunked, test_oft_kohya_non_fused, @@ -1271,6 +1641,7 @@ def run_tests(): test_ia3_calc_updown_shape, test_glora_calc_updown_shape, test_full_calc_updown_shape, + test_dora_ordering_matches_lycoris, ]: run_test(CAT_MATH, fn) diff --git a/test/test-krea2-transformer.py b/test/test-krea2-transformer.py index b46341f71..53e62b998 100644 --- a/test/test-krea2-transformer.py +++ b/test/test-krea2-transformer.py @@ -8,8 +8,12 @@ - Zero-init regression: a checkpoint that omits the dormant last.up/last.down residual branch, after materialize_zero_init, produces the same output as the base whose up is zeroed. Port only, so it runs without the reference. +- comfy_quant real-file (opt-in): loads an actual ComfyUI int8_tensorwise Krea2 single file + through the native loader and verifies SDNQ adoption plus a finite tiny forward. Enabled by + setting $KREA2_COMFY_FILE to the .safetensors path; needs network for the base repo config + ($KREA2_COMFY_REPO, default CalamitousFelicitousness/Krea-2-Base-Diffusers). -No server, no checkpoint. +No server, no checkpoint (except the opt-in comfy_quant test). """ import importlib.util @@ -89,8 +93,8 @@ def run_parity(mmdit, port): print("PARITY OK") -def load_materialize_zero_init(): - """Import the real loader helper. native_transformer pulls in modules.shared, which needs +def bootstrap_repo(): + """Make repo modules importable. native_transformer pulls in modules.shared, which needs cmd_args parsed first, so bootstrap it the same way the native-transformer suite does.""" repo = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) if repo not in sys.path: @@ -106,6 +110,10 @@ def load_materialize_zero_init(): sys.argv = orig_argv installer.add_args(modules.cmd_args.parser) modules.cmd_args.parsed, _ = modules.cmd_args.parser.parse_known_args([]) + + +def load_materialize_zero_init(): + bootstrap_repo() from pipelines.native_transformer import materialize_zero_init return materialize_zero_init @@ -159,12 +167,61 @@ def run_zero_init_regression(port): print("ZERO-INIT OK") +def run_comfy_quant_real_file(): + """Opt-in end-to-end check against a real ComfyUI int8_tensorwise Krea2 file: the native + loader must adopt every marked linear as an SDNQ int8 layer and produce a finite output on + a tiny forward. $KREA2_COMFY_LAYERS overrides the expected layer count (default 224).""" + path = os.environ.get("KREA2_COMFY_FILE") + if not path: + print("COMFY REAL-FILE SKIPPED (set KREA2_COMFY_FILE to enable)") + return + assert os.path.exists(path), f"KREA2_COMFY_FILE not found: {path}" + expected_layers = int(os.environ.get("KREA2_COMFY_LAYERS", "224")) + repo_id = os.environ.get("KREA2_COMFY_REPO", "CalamitousFelicitousness/Krea-2-Base-Diffusers") + + bootstrap_repo() + from pipelines import native_transformer as nt + from pipelines.krea2 import KREA2_SPEC + + transformer, siblings = nt.load(local_file=path, repo_id=repo_id, spec=KREA2_SPEC, diffusers_cfg={}) + assert siblings == {} + + sdnq_layers = [m for m in transformer.modules() if m.__class__.__name__ == "SDNQLinear"] + storage_dtypes = {m.weight.dtype for m in sdnq_layers} + print(f"comfy_quant real file: {len(sdnq_layers)} SDNQ layers, storage {storage_dtypes}") + assert len(sdnq_layers) == expected_layers, f"expected {expected_layers} SDNQ layers, got {len(sdnq_layers)}" + assert storage_dtypes <= {torch.int8, torch.float8_e4m3fn, torch.uint8}, f"unexpected storage dtypes: {storage_dtypes}" + assert len(storage_dtypes) == 1, "adopted weights must share one storage dtype" + assert transformer.blocks[0].attn.wq.__class__.__name__ == "SDNQLinear" + assert getattr(transformer, "quantization_config", None) is not None + + cfg = transformer.config + param = next(p for p in transformer.parameters() if p.is_floating_point()) + device, dtype = param.device, param.dtype + batch, txtlen, imglen = 1, 3, 4 + seq = txtlen + imglen + gen = torch.Generator().manual_seed(1) + img = torch.randn(batch, imglen, cfg.channels * cfg.patch ** 2, generator=gen).to(device=device, dtype=dtype) + context = torch.randn(batch, txtlen, cfg.txtlayers, cfg.txtdim, generator=gen).to(device=device, dtype=dtype) + timestep = torch.rand(batch, generator=gen).to(device=device, dtype=dtype) + pos = torch.randint(0, 16, (batch, seq, 3), generator=gen).float().to(device=device) + mask = torch.ones(batch, seq, dtype=torch.bool, device=device) + with torch.no_grad(): + out = transformer( + hidden_states=img, encoder_hidden_states=context, timestep=timestep, + position_ids=pos, attention_mask=mask, return_dict=False, + )[0] + assert torch.isfinite(out).all(), "forward produced non-finite values" + print("COMFY REAL-FILE OK") + + def main(): port = load_port() # Parity runs first in pristine torch state; the regression imports modules afterwards. mmdit = load_reference() run_parity(mmdit, port) run_zero_init_regression(port) + run_comfy_quant_real_file() if __name__ == "__main__": diff --git a/test/test-native-transformer.py b/test/test-native-transformer.py index dc577dadd..4c0befcc5 100644 --- a/test/test-native-transformer.py +++ b/test/test-native-transformer.py @@ -4,9 +4,12 @@ Offline unit tests for pipelines.native_transformer. Covers the pure helpers that own per-arch knob handling: +- ``drop_companion_keys`` for filtering bundled TE/VAE families out of all-in-one files - ``strip_prefix`` for single/multi prefix detection and mixed-prefix rejection - ``partition_siblings`` for inline-sibling key partitioning - ``check_forbidden_markers`` for structural-mismatch rejection +- ``detect_comfy_quant`` for comfy_quant marker detection and format gating +- ``remap_comfy_quant`` for comfy_quant -> SDNQ key translation - ``is_noop_converter`` for diffusers no-op lambda detection - ``validate_state_dict_load`` for unexpected / missing key handling - ``make_default_spec`` default-spec synthesis with diffusers converter pickup @@ -94,6 +97,61 @@ def run_test(cat: str, fn): traceback.print_exc() +# ============================================================ +# drop_companion_keys +# ============================================================ + +def test_drop_companion_keys_no_companions_pass_through(): + sd = {'net.blocks.0.weight': 1, 'net.blocks.1.weight': 2} + out = nt.drop_companion_keys(sd, nt.DEFAULT_IGNORED_PREFIXES, 'Test') + assert out == sd, 'files without companion keys must pass through unchanged' + + +def test_drop_companion_keys_filters_all_in_one_layout(): + sd = { + 'net.blocks.0.weight': 1, + 'net.llm_adapter.proj.weight': 2, + 'cond_stage_model.qwen3_06b.transformer.model.embed_tokens.weight': 3, + 'first_stage_model.decoder.conv1.weight': 4, + 'vae.decoder.conv_in.weight': 5, + 'text_encoders.clip_l.weight': 6, + } + out = nt.drop_companion_keys(sd, nt.DEFAULT_IGNORED_PREFIXES, 'Test') + assert set(out.keys()) == {'net.blocks.0.weight', 'net.llm_adapter.proj.weight'} + + +def test_drop_companion_keys_raises_when_nothing_left(): + sd = { + 'cond_stage_model.te.weight': 1, + 'first_stage_model.decoder.weight': 2, + } + try: + nt.drop_companion_keys(sd, nt.DEFAULT_IGNORED_PREFIXES, 'Test') + raise AssertionError('expected ValueError') + except ValueError as e: + assert 'no transformer keys' in str(e) + + +def test_drop_companion_keys_empty_prefix_tuple_no_op(): + sd = {'cond_stage_model.te.weight': 1} + out = nt.drop_companion_keys(sd, (), 'Test') + assert out == sd, 'empty ignored_prefixes must disable filtering' + + +def test_drop_then_strip_all_in_one_layout(): + """Companion filtering must clear the way for normal prefix detection.""" + sd = { + 'net.blocks.0.weight': 1, + 'net.final_layer.weight': 2, + 'cond_stage_model.te.weight': 3, + 'first_stage_model.decoder.weight': 4, + } + out = nt.drop_companion_keys(sd, nt.DEFAULT_IGNORED_PREFIXES, 'Test') + out, prefix = nt.strip_prefix(out, nt.DEFAULT_PREFIXES, 'Test') + assert prefix == 'net.' + assert set(out.keys()) == {'blocks.0.weight', 'final_layer.weight'} + + # ============================================================ # strip_prefix # ============================================================ @@ -238,6 +296,409 @@ def test_forbidden_markers_empty_tuple_no_op(): nt.check_forbidden_markers(sd, (), 'Test', '/tmp/x.safetensors') +# ============================================================ +# detect_comfy_quant / remap_comfy_quant +# ============================================================ + +def comfy_marker(fmt: str) -> torch.Tensor: + import json + return torch.tensor(list(json.dumps({'format': fmt}).encode()), dtype=torch.uint8) + + +def test_detect_comfy_no_markers_returns_none(): + sd = {'blocks.0.attn.wq.weight': torch.zeros(2), 'blocks.0.attn.wq.bias': torch.zeros(2)} + assert nt.detect_comfy_quant(sd, 'Test') is None + + +def test_detect_comfy_valid_markers(): + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.attn.wq.weight_scale': torch.tensor(0.5), + 'blocks.0.attn.wq.comfy_quant': comfy_marker('int8_tensorwise'), + 'blocks.0.mlp.up.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.mlp.up.weight_scale': torch.tensor(0.25), + 'blocks.0.mlp.up.comfy_quant': comfy_marker('int8_tensorwise'), + 'norm.weight': torch.zeros(4), + } + detected = nt.detect_comfy_quant(sd, 'Test') + assert detected is not None + marked, fmt = detected + assert set(marked) == {'blocks.0.attn.wq', 'blocks.0.mlp.up'} + assert marked['blocks.0.attn.wq'] == {'format': 'int8_tensorwise'} + assert fmt == 'int8_tensorwise' + + +def test_detect_comfy_unsupported_format_raises(): + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4)), + 'blocks.0.attn.wq.comfy_quant': comfy_marker('float8_e4m3fn_scaled'), + } + try: + nt.detect_comfy_quant(sd, 'Test') + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'float8_e4m3fn_scaled' in str(e) + + +def test_detect_comfy_malformed_marker_raises(): + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4)), + 'blocks.0.attn.wq.comfy_quant': torch.tensor(list(b'not json'), dtype=torch.uint8), + } + try: + nt.detect_comfy_quant(sd, 'Test') + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'malformed' in str(e) + + +def test_detect_comfy_convrot_accepted(): + """ConvRot markers map onto SDNQ's Hadamard support; detection carries the + per-layer fields through instead of rejecting.""" + import json + payload = json.dumps({'format': 'int8_tensorwise', 'convrot': True, 'convrot_groupsize': 256, 'per_row': True}) + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.attn.wq.comfy_quant': torch.tensor(list(payload.encode()), dtype=torch.uint8), + 'blocks.0.mlp.up.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.mlp.up.comfy_quant': comfy_marker('int8_tensorwise'), + } + marked, fmt = nt.detect_comfy_quant(sd, 'Test') + assert fmt == 'int8_tensorwise' + assert marked['blocks.0.attn.wq'].get('convrot') is True + assert marked['blocks.0.attn.wq'].get('convrot_groupsize') == 256 + assert not marked['blocks.0.mlp.up'].get('convrot') + + +def test_detect_comfy_convrot_bad_groupsize_raises(): + """Regular Hadamards only exist for power-of-4 sizes; any other convrot + group size cannot be a compatible rotation.""" + import json + payload = json.dumps({'format': 'int8_tensorwise', 'convrot': True, 'convrot_groupsize': 8}) + sd = { + 'blocks.0.attn.wq.comfy_quant': torch.tensor(list(payload.encode()), dtype=torch.uint8), + } + try: + nt.detect_comfy_quant(sd, 'Test') + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'power of 4' in str(e) + + +def test_detect_comfy_marker_missing_format_field_raises(): + import json + sd = { + 'blocks.0.attn.wq.comfy_quant': torch.tensor(list(json.dumps({'fmt': 'x'}).encode()), dtype=torch.uint8), + } + try: + nt.detect_comfy_quant(sd, 'Test') + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'malformed' in str(e) + + +def test_remap_comfy_renames_and_reshapes_scale(): + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.attn.wq.weight_scale': torch.tensor(0.5), + 'blocks.0.attn.wq.comfy_quant': comfy_marker('int8_tensorwise'), + } + out = nt.remap_comfy_quant(sd, {'blocks.0.attn.wq'}) + assert set(out.keys()) == {'blocks.0.attn.wq.weight', 'blocks.0.attn.wq.scale'} + assert out['blocks.0.attn.wq.scale'].shape == (1, 1) + assert out['blocks.0.attn.wq.scale'].item() == 0.5 + assert out['blocks.0.attn.wq.weight'].dtype == torch.int8 + + +def test_remap_comfy_passes_unmarked_keys_verbatim(): + unrelated_scale = torch.tensor(2.0) + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.attn.wq.weight_scale': torch.tensor(0.5), + 'blocks.0.attn.wq.comfy_quant': comfy_marker('int8_tensorwise'), + 'norm.weight': torch.ones(4), + 'other.weight_scale': unrelated_scale, + } + out = nt.remap_comfy_quant(sd, {'blocks.0.attn.wq'}) + assert 'norm.weight' in out + assert out['other.weight_scale'] is unrelated_scale, 'weight_scale outside marked names must pass through untouched' + + +def test_remap_comfy_does_not_mutate_input(): + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.attn.wq.weight_scale': torch.tensor(0.5), + 'blocks.0.attn.wq.comfy_quant': comfy_marker('int8_tensorwise'), + } + keys_before = set(sd.keys()) + nt.remap_comfy_quant(sd, {'blocks.0.attn.wq'}) + assert set(sd.keys()) == keys_before, 'input dict must not be mutated (read_state_dict caches it)' + + +def test_remap_comfy_drops_input_scale(): + """Optional activation-calibration sidecars are dropped for marked layers + (SDNQ derives activation scales dynamically); unmarked ones pass through.""" + unrelated = torch.tensor(1.0) + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.attn.wq.weight_scale': torch.tensor(0.5), + 'blocks.0.attn.wq.input_scale': torch.tensor(0.125), + 'blocks.0.attn.wq.comfy_quant': comfy_marker('int8_tensorwise'), + 'other.input_scale': unrelated, + } + out = nt.remap_comfy_quant(sd, {'blocks.0.attn.wq'}) + assert 'blocks.0.attn.wq.input_scale' not in out + assert out['other.input_scale'] is unrelated + + +# ============================================================ +# header _quantization_metadata +# ============================================================ + +def quant_metadata(layers: dict) -> dict: + import json + return {'_quantization_metadata': json.dumps({'format_version': '1.0', 'layers': layers})} + + +def test_read_quant_metadata_absent_returns_none(): + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + write_fixture({'a.weight': torch.zeros(2)}, fd, path) + assert nt.read_quantization_metadata(path) is None + finally: + os.unlink(path) + + +def test_read_quant_metadata_parses_layers(): + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + layers = {'blocks.0.attn.wq': {'format': 'int8_tensorwise'}} + write_fixture({'blocks.0.attn.wq.weight': torch.zeros(2)}, fd, path, metadata=quant_metadata(layers)) + assert nt.read_quantization_metadata(path) == layers + finally: + os.unlink(path) + + +def test_read_quant_metadata_malformed_raises(): + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + write_fixture({'a.weight': torch.zeros(2)}, fd, path, metadata={'_quantization_metadata': 'not json'}) + try: + nt.read_quantization_metadata(path) + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'malformed' in str(e) + finally: + os.unlink(path) + + +def test_read_quant_metadata_non_dict_layers_raises(): + import json + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + payload = json.dumps({'layers': {'blocks.0.attn.wq': 'int8_tensorwise'}}) + write_fixture({'a.weight': torch.zeros(2)}, fd, path, metadata={'_quantization_metadata': payload}) + try: + nt.read_quantization_metadata(path) + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'malformed' in str(e) + finally: + os.unlink(path) + + +def test_transcode_quant_metadata_synthesizes_markers(): + """Header entries become marker tensors for layers whose weight is present; + entries without a matching weight (companion components) are skipped.""" + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.attn.wq.weight_scale': torch.tensor(0.5), + } + layers = { + 'blocks.0.attn.wq': {'format': 'int8_tensorwise'}, + 'text_encoder.mlp.up': {'format': 'int8_tensorwise'}, + } + out, source = nt.transcode_quant_metadata(sd, layers) + assert source == 'header' + assert 'blocks.0.attn.wq.comfy_quant' in out + assert 'text_encoder.mlp.up.comfy_quant' not in out + assert 'blocks.0.attn.wq.comfy_quant' not in sd, 'input dict must not be mutated' + marked, fmt = nt.detect_comfy_quant(out, 'Test') + assert fmt == 'int8_tensorwise' + assert marked['blocks.0.attn.wq'] == {'format': 'int8_tensorwise'} + + +def test_transcode_quant_metadata_header_wins(): + """When both forms are present the header entry overwrites the marker, + matching the reference loader's precedence.""" + sd = { + 'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8), + 'blocks.0.attn.wq.comfy_quant': comfy_marker('float8_e4m3fn'), + } + layers = {'blocks.0.attn.wq': {'format': 'int8_tensorwise', 'full_precision_matrix_mult': True}} + out, source = nt.transcode_quant_metadata(sd, layers) + assert source == 'both' + marked, fmt = nt.detect_comfy_quant(out, 'Test') + assert fmt == 'int8_tensorwise' + assert marked['blocks.0.attn.wq'].get('full_precision_matrix_mult') is True + + +def test_transcode_quant_metadata_no_matches_is_noop(): + sd = {'blocks.0.attn.wq.weight': torch.zeros((4, 4), dtype=torch.int8)} + out, source = nt.transcode_quant_metadata(sd, {'unrelated.layer': {'format': 'int8_tensorwise'}}) + assert source == 'markers' + assert out is sd + + +# ============================================================ +# nvfp4: sdnq codec, scale unswizzle, detection +# ============================================================ + +E2M1_VALUES = (0.0, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, -0.0, -0.5, -1.0, -1.5, -2.0, -3.0, -4.0, -6.0) + + +def to_blocked_reference(matrix: torch.Tensor) -> torch.Tensor: + """cuBLAS block-scaling tile layout as written into nvfp4 containers; + the loader's unswizzle must invert this exactly.""" + rows, cols = matrix.shape + row_blocks = -(rows // -128) + col_blocks = -(cols // -4) + padded = torch.zeros((row_blocks * 128, col_blocks * 4), dtype=matrix.dtype) + padded[:rows, :cols] = matrix + blocks = padded.view(row_blocks, 128, col_blocks, 4).permute(0, 2, 1, 3) + rearranged = blocks.reshape(-1, 4, 32, 4).transpose(1, 2).reshape(-1, 32, 16) + return rearranged.reshape(row_blocks * 128, col_blocks * 4) + + +def test_unswizzle_block_scales_roundtrip(): + for rows, groups in ((128, 4), (8, 3), (200, 10)): + mat = torch.arange(rows * groups, dtype=torch.float32).reshape(rows, groups) + back = nt.unswizzle_block_scales(to_blocked_reference(mat), rows, groups) + assert torch.equal(back, mat), f'unswizzle mismatch for {(rows, groups)}' + + +def test_nvfp4_codec_ocp_table(): + """SDNQ's float4_e2m1fn decodes OCP FP4 E2M1 exactly, including the + subnormal codes 1/9 as +/-0.5; nvfp4 containers adopt it directly.""" + from modules.sdnq.packed_float import unpack_float + packed = torch.tensor([(2 * j) | (((2 * j) + 1) << 4) for j in range(8)], dtype=torch.uint8) + dec = unpack_float(packed, 'float4_e2m1fn', torch.Size([16])) + for code in range(16): + assert float(dec[code]) == E2M1_VALUES[code], f'code {code}: {float(dec[code])} != {E2M1_VALUES[code]}' + + +def test_nvfp4_pack_ocp_grid_roundtrip(): + """Every OCP grid value survives a pack/unpack round trip exactly + (subnormals included), and off-grid values land inside the value set. + Exact nearest-rounding near the grid midpoints is not asserted: the + packer's staged rounding may resolve boundary values to either side.""" + from modules.sdnq.packed_float import pack_float, unpack_float + grid = [0.0, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, -0.5, -1.0, -1.5, -2.0, -3.0, -4.0, -6.0, 0.0] + vals = torch.tensor(grid, dtype=torch.float32) + out = unpack_float(pack_float(vals, 'float4_e2m1fn'), 'float4_e2m1fn', vals.shape) + assert torch.equal(out, vals), f'grid values must roundtrip exactly: {out.tolist()}' + off_grid = torch.tensor([0.2, 0.6, 0.9, 1.2, 2.4, 5.5, -0.4, -0.9, -1.7, -3.4, -5.9, 0.05, 0.99, -0.99], dtype=torch.float32) + out = unpack_float(pack_float(off_grid, 'float4_e2m1fn'), 'float4_e2m1fn', off_grid.shape) + for v, o in zip(off_grid.tolist(), out.tolist()): + assert abs(o) in {0.0, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0}, f'{v} -> {o} outside the OCP set' + + +def test_detect_comfy_nvfp4_marker_accepted(): + import json + payload = json.dumps({'format': 'nvfp4', 'group_size': 16, 'orig_dtype': 'torch.float16', 'orig_shape': [32, 32]}) + sd = { + 'in_proj.weight': torch.zeros((32, 16), dtype=torch.uint8), + 'in_proj.comfy_quant': torch.tensor(list(payload.encode()), dtype=torch.uint8), + } + marked, fmt = nt.detect_comfy_quant(sd, 'Test') + assert fmt == 'nvfp4' + assert marked['in_proj']['orig_shape'] == [32, 32] + + +def test_detect_comfy_nvfp4_bad_group_size_raises(): + import json + payload = json.dumps({'format': 'nvfp4', 'group_size': 32}) + sd = {'a.comfy_quant': torch.tensor(list(payload.encode()), dtype=torch.uint8)} + try: + nt.detect_comfy_quant(sd, 'Test') + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'group_size' in str(e) + + +def test_detect_comfy_nvfp4_convrot_raises(): + import json + payload = json.dumps({'format': 'nvfp4', 'convrot': True, 'convrot_groupsize': 16}) + sd = {'a.comfy_quant': torch.tensor(list(payload.encode()), dtype=torch.uint8)} + try: + nt.detect_comfy_quant(sd, 'Test') + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'convrot' in str(e) + + +# ============================================================ +# model_probe quant detection (header-only, mirrors the loader's coverage) +# ============================================================ + +def test_probe_detects_header_quant_metadata(): + import json + from modules import model_probe + header = { + '__metadata__': {'_quantization_metadata': json.dumps({'layers': {'blocks.0.wq': {'format': 'float8_e4m3fn'}}})}, + 'blocks.0.wq.weight': {'dtype': 'F8_E4M3', 'shape': [4, 4]}, + 'blocks.0.wq.weight_scale': {'dtype': 'F32', 'shape': []}, + } + quant = model_probe.analyze_header(header)['quant'] + assert quant == {'scheme': 'comfy_quant', 'format': 'float8_e4m3fn', 'marked_layers': 1, 'source': 'header'} + + +def test_probe_resolves_nvfp4_from_weight_dtype(): + from modules import model_probe + header = { + 'model.diffusion_model.blocks.0.wq.weight': {'dtype': 'U8', 'shape': [32, 16]}, + 'model.diffusion_model.blocks.0.wq.weight_scale': {'dtype': 'F8_E4M3', 'shape': [128, 4]}, + 'model.diffusion_model.blocks.0.wq.weight_scale_2': {'dtype': 'F32', 'shape': []}, + 'model.diffusion_model.blocks.0.wq.comfy_quant': {'dtype': 'U8', 'shape': [60]}, + } + quant = model_probe.analyze_header(header)['quant'] + assert quant['format'] == 'nvfp4' + assert quant['source'] == 'weight-dtype' + + +def test_probe_fp8_markers_despite_u8_noise(): + """The marked layer's own weight dtype decides the format; unrelated U8 + tensors must not outvote it.""" + from modules import model_probe + header = { + 'blocks.0.wq.weight': {'dtype': 'F8_E4M3', 'shape': [8, 8]}, + 'blocks.0.wq.weight_scale': {'dtype': 'F32', 'shape': []}, + 'blocks.0.wq.comfy_quant': {'dtype': 'U8', 'shape': [27]}, + 'extra.blob1': {'dtype': 'U8', 'shape': [64]}, + 'extra.blob2': {'dtype': 'U8', 'shape': [64]}, + } + quant = model_probe.analyze_header(header)['quant'] + assert quant['format'] == 'float8_e4m3fn' + + +def test_probe_int8_markers(): + from modules import model_probe + header = { + 'blocks.0.wq.weight': {'dtype': 'I8', 'shape': [8, 8]}, + 'blocks.0.wq.weight_scale': {'dtype': 'F32', 'shape': []}, + 'blocks.0.wq.comfy_quant': {'dtype': 'U8', 'shape': [29]}, + } + quant = model_probe.analyze_header(header)['quant'] + assert quant['format'] == 'int8_tensorwise' + assert quant['marked_layers'] == 1 + + +def test_probe_plain_file_no_quant(): + from modules import model_probe + header = {'blocks.0.wq.weight': {'dtype': 'BF16', 'shape': [8, 8]}} + assert model_probe.analyze_header(header)['quant']['scheme'] is None + + # ============================================================ # is_noop_converter # ============================================================ @@ -380,6 +841,7 @@ def test_transformer_spec_defaults(): assert spec.converter is None assert spec.siblings == {} assert spec.acceptable_missing == ('rope.', 'pos_embedder.', 'learnable_pos_embed.') + assert spec.ignored_prefixes == ('cond_stage_model.', 'conditioner.', 'first_stage_model.', 'text_encoders.', 'vae.') assert spec.forbidden_markers == () @@ -441,9 +903,9 @@ class MockKwargsTransformer(MockMiniTransformer): return cls(dim=config['dim']) -def write_fixture(state_dict_keys: dict, fd: int, path: str) -> str: +def write_fixture(state_dict_keys: dict, fd: int, path: str, metadata: dict | None = None) -> str: os.close(fd) - safetensors.torch.save_file(state_dict_keys, path) + safetensors.torch.save_file(state_dict_keys, path, metadata=metadata) return path @@ -774,11 +1236,988 @@ def test_load_converter_crash_raises_mismatch(): os.unlink(path) +# ============================================================ +# Ideogram 4 converter (fused community layout -> diffusers layout) +# ============================================================ + +def ideogram_converter(): + from pipelines.ideogram import convert_ideogram4_transformer_checkpoint + return convert_ideogram4_transformer_checkpoint + + +def test_ideogram4_converter_splits_fused_qkv_weight(): + convert = ideogram_converter() + fused = torch.arange(48, dtype=torch.float32).reshape(12, 4) + out = convert({'layers.0.attention.qkv.weight': fused}) + assert set(out.keys()) == {f'layers.0.attention.{n}.weight' for n in ('to_q', 'to_k', 'to_v')} + assert torch.equal(out['layers.0.attention.to_q.weight'], fused[0:4]) + assert torch.equal(out['layers.0.attention.to_k.weight'], fused[4:8]) + assert torch.equal(out['layers.0.attention.to_v.weight'], fused[8:12]) + + +def test_ideogram4_converter_splits_rowwise_scale(): + convert = ideogram_converter() + fused = torch.zeros((12, 4), dtype=torch.int8) + scale = torch.arange(12, dtype=torch.float32).reshape(12, 1) + out = convert({'layers.3.attention.qkv.weight': fused, 'layers.3.attention.qkv.weight_scale': scale}) + assert torch.equal(out['layers.3.attention.to_q.weight_scale'], scale[0:4]) + assert torch.equal(out['layers.3.attention.to_v.weight_scale'], scale[8:12]) + assert out['layers.3.attention.to_k.weight_scale'].shape == (4, 1) + + +def test_ideogram4_converter_scalar_scale_copied_not_sliced(): + convert = ideogram_converter() + fused = torch.zeros((12, 4), dtype=torch.int8) + scale = torch.tensor(0.5) + out = convert({'layers.0.attention.qkv.weight': fused, 'layers.0.attention.qkv.weight_scale': scale}) + for name in ('to_q', 'to_k', 'to_v'): + assert out[f'layers.0.attention.{name}.weight_scale'] is scale + + +def test_ideogram4_converter_duplicates_marker(): + convert = ideogram_converter() + fused = torch.zeros((12, 4), dtype=torch.int8) + marker = comfy_marker('int8_tensorwise') + out = convert({'layers.0.attention.qkv.weight': fused, 'layers.0.attention.qkv.comfy_quant': marker}) + for name in ('to_q', 'to_k', 'to_v'): + assert out[f'layers.0.attention.{name}.comfy_quant'] is marker + + +def test_ideogram4_converter_renames_o_with_sidecars(): + convert = ideogram_converter() + sd = { + 'layers.5.attention.o.weight': torch.zeros((4, 4), dtype=torch.int8), + 'layers.5.attention.o.weight_scale': torch.tensor(1.0), + 'layers.5.attention.o.comfy_quant': comfy_marker('int8_tensorwise'), + } + out = convert(sd) + assert set(out.keys()) == { + 'layers.5.attention.to_out.0.weight', + 'layers.5.attention.to_out.0.weight_scale', + 'layers.5.attention.to_out.0.comfy_quant', + } + + +def test_ideogram4_converter_passthrough(): + convert = ideogram_converter() + sd = { + 'input_proj.weight': torch.zeros(4), + 'llm_cond_proj.weight': torch.zeros(4), + 'layers.0.feed_forward.w1.weight': torch.zeros(4), + 'layers.0.attention.norm_q.weight': torch.zeros(4), + 'layers.0.adaln_modulation.bias': torch.zeros(4), + 'final_layer.linear.weight': torch.zeros(4), + } + out = convert(sd) + assert set(out.keys()) == set(sd.keys()) + for k, v in sd.items(): + assert out[k] is v + + +def test_ideogram4_converter_defensive_bias_split(): + convert = ideogram_converter() + fused = torch.zeros((12, 4), dtype=torch.float32) + bias = torch.arange(12, dtype=torch.float32) + out = convert({'layers.0.attention.qkv.weight': fused, 'layers.0.attention.qkv.bias': bias}) + assert torch.equal(out['layers.0.attention.to_k.bias'], bias[4:8]) + + +def test_ideogram4_converter_does_not_mutate_input(): + convert = ideogram_converter() + sd = { + 'layers.0.attention.qkv.weight': torch.zeros((12, 4)), + 'layers.0.attention.o.weight': torch.zeros((4, 4)), + 'input_proj.weight': torch.zeros(4), + } + keys_before = set(sd.keys()) + convert(sd) + assert set(sd.keys()) == keys_before + + +# ============================================================ +# Integration: comfy_quant pre-quantized load +# ============================================================ +# Same patching strategy as the plain load tests, plus pinned SDNQ opts so the +# builder's settings reads are deterministic. dtype=float32 makes the dequant +# math bit-exact against a manual int8 * scale reference. + +def comfy_fixture(dim: int, fmt: str = 'int8_tensorwise') -> dict: + """comfy_quant export shape: in_proj carries a quantized weight + scalar + fp32 scale + marker; out_proj and biases stay plain f16.""" + if fmt == 'float8_e4m3fn': + weight = torch.randn(dim, dim).to(torch.float8_e4m3fn) + else: + weight = torch.randint(-128, 127, (dim, dim), dtype=torch.int8) + return { + 'model.diffusion_model.in_proj.weight': weight, + 'model.diffusion_model.in_proj.weight_scale': torch.tensor(0.03125, dtype=torch.float32), + 'model.diffusion_model.in_proj.comfy_quant': comfy_marker(fmt), + 'model.diffusion_model.in_proj.bias': torch.randn(dim, dtype=torch.float16), + 'model.diffusion_model.out_proj.weight': torch.randn(dim, dim, dtype=torch.float16), + 'model.diffusion_model.out_proj.bias': torch.zeros(dim, dtype=torch.float16), + } + + +class ComfyTestEnv: + """Patches quant helpers + config fetch and pins the SDNQ opts the + prequantized builder reads, restoring everything on exit. + ``fp8_compile_supported`` pins the fp8 storage-remap decision so tests + behave identically regardless of the host GPU and compile settings.""" + + def __init__(self, dim: int, fp8_compile_supported: bool = True): + self.dim = dim + self.fp8_compile_supported = fp8_compile_supported + + def __enter__(self): + from modules import model_quant, shared + from modules.sdnq import common as sdnq_common + self.shared = shared + self.sdnq_common = sdnq_common + self.orig_fetch = nt.fetch_component_config + self.orig_get_dit = model_quant.get_dit_args + self.orig_get_qtype = model_quant.get_quant_type + self.orig_do_post = model_quant.do_post_load_quant + self.orig_fp8_supported = sdnq_common.is_fp8_compile_supported + self.orig_check_compile = sdnq_common.check_torch_compile + self.model_quant = model_quant + nt.fetch_component_config = lambda repo, sub: {'dim': self.dim} + model_quant.get_dit_args = lambda *a, **k: ({}, {}) + model_quant.get_quant_type = lambda *a, **k: None + model_quant.do_post_load_quant = lambda *a, **k: None + sdnq_common.is_fp8_compile_supported = self.fp8_compile_supported + sdnq_common.check_torch_compile = lambda: not self.fp8_compile_supported + self.orig_opts = { + 'sdnq_use_quantized_matmul': shared.opts.sdnq_use_quantized_matmul, + 'sdnq_dequantize_fp32': shared.opts.sdnq_dequantize_fp32, + 'diffusers_offload_mode': shared.opts.diffusers_offload_mode, + } + shared.opts.data['sdnq_use_quantized_matmul'] = False + shared.opts.data['sdnq_dequantize_fp32'] = True + shared.opts.data['diffusers_offload_mode'] = 'model' # force CPU placement + return self + + def __exit__(self, *exc): + nt.fetch_component_config = self.orig_fetch + self.model_quant.get_dit_args = self.orig_get_dit + self.model_quant.get_quant_type = self.orig_get_qtype + self.model_quant.do_post_load_quant = self.orig_do_post + self.sdnq_common.is_fp8_compile_supported = self.orig_fp8_supported + self.sdnq_common.check_torch_compile = self.orig_check_compile + for key, value in self.orig_opts.items(): + self.shared.opts.data[key] = value + return False + + +def test_load_comfy_int8_end_to_end(): + """Full pipeline on a comfy_quant fixture: the marked linear becomes an + SDNQ int8 layer holding the file's exact tensors, the unmarked linear + loads plain, and the forward pass matches a dequantized reference.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = comfy_fixture(dim) + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, siblings = nt.load( + local_file=path, + repo_id='fake/repo', + spec=spec, + diffusers_cfg={}, + dtype=torch.float32, + ) + + assert siblings == {} + in_proj = transformer.in_proj + assert in_proj.__class__.__name__ == 'SDNQLinear', f'marked layer is {in_proj.__class__.__name__}' + dq = in_proj.sdnq_dequantizer + assert dq.weights_dtype == 'int8' + assert dq.group_size == -1 + assert dq.use_quantized_matmul is False + assert dq.original_shape == (dim, dim) + + # File tensors adopted bit-exact: int8 codes and fp32 scalar scale. + assert in_proj.weight.dtype == torch.int8 + assert torch.equal(in_proj.weight.detach().cpu(), raw['model.diffusion_model.in_proj.weight']) + assert in_proj.scale.dtype == torch.float32 + assert tuple(in_proj.scale.shape) == (1, 1) + assert in_proj.scale.item() == raw['model.diffusion_model.in_proj.weight_scale'].item() + assert in_proj.zero_point is None + + # Dequant matches comfy semantics exactly: fp = int8.float() * scale. + expected = raw['model.diffusion_model.in_proj.weight'].float() * raw['model.diffusion_model.in_proj.weight_scale'] + dequantized = dq(in_proj.weight, in_proj.scale, zero_point=None, svd_up=None, svd_down=None) + assert torch.equal(dequantized.detach().cpu(), expected) + + # Forward parity against a reference built from the dequantized weight. + x = torch.randn(2, dim) + out = in_proj(x) + ref = torch.nn.functional.linear(x, expected, in_proj.bias.detach().cpu()) + assert torch.allclose(out.detach().cpu(), ref, atol=1e-6) + + # Unmarked layer loads as a plain Linear cast to the target dtype. + assert transformer.out_proj.__class__ is torch.nn.Linear + assert transformer.out_proj.weight.dtype == torch.float32 + assert torch.allclose( + transformer.out_proj.weight.detach().cpu(), + raw['model.diffusion_model.out_proj.weight'].float(), + ) + + # Marked as SDNQ-quantized so downstream never re-quantizes. + assert getattr(transformer, 'quantization_config', None) is not None + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_fp8_end_to_end(): + """float8_e4m3fn variant: same container, fp8 storage. The marked linear + must keep fp8 codes and dequantize as weight.float() * scale.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = comfy_fixture(dim, fmt='float8_e4m3fn') + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, _ = nt.load( + local_file=path, + repo_id='fake/repo', + spec=spec, + diffusers_cfg={}, + dtype=torch.float32, + ) + + in_proj = transformer.in_proj + assert in_proj.__class__.__name__ == 'SDNQLinear' + assert in_proj.sdnq_dequantizer.weights_dtype == 'float8_e4m3fn' + assert in_proj.weight.dtype == torch.float8_e4m3fn + assert in_proj.scale.dtype == torch.float32 + + expected = raw['model.diffusion_model.in_proj.weight'].float() * raw['model.diffusion_model.in_proj.weight_scale'] + dequantized = in_proj.sdnq_dequantizer(in_proj.weight, in_proj.scale, zero_point=None, svd_up=None, svd_down=None) + assert torch.equal(dequantized.detach().cpu(), expected) + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_fp8_remaps_storage_when_compile_unsupported(): + """When compiled dequant is on but the hardware cannot compile e4m3, + fp8 weights are adopted through the uint8-backed codec: identical + decoded values from storage the compiler can always touch.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = comfy_fixture(dim, fmt='float8_e4m3fn') + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim, fp8_compile_supported=False): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, _ = nt.load( + local_file=path, + repo_id='fake/repo', + spec=spec, + diffusers_cfg={}, + dtype=torch.float32, + ) + + in_proj = transformer.in_proj + assert in_proj.__class__.__name__ == 'SDNQLinear' + assert in_proj.sdnq_dequantizer.weights_dtype == 'float8_e4m3fn_sdnq' + assert in_proj.weight.dtype == torch.uint8 + expected = raw['model.diffusion_model.in_proj.weight'].float() * raw['model.diffusion_model.in_proj.weight_scale'] + dequantized = in_proj.sdnq_dequantizer(in_proj.weight, in_proj.scale, zero_point=None, svd_up=None, svd_down=None) + assert torch.equal(dequantized.detach().cpu(), expected) + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_metadata_end_to_end(): + """Marker-less container: quant info only in the header + _quantization_metadata, layer names carrying the file's tensor prefix. + The load path must re-key through the prefix strip and land on the same + prequantized build as the marker form.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = comfy_fixture(dim) + del raw['model.diffusion_model.in_proj.comfy_quant'] + layers = {'model.diffusion_model.in_proj': {'format': 'int8_tensorwise'}} + write_fixture(raw, fd, path, metadata=quant_metadata(layers)) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, _ = nt.load( + local_file=path, + repo_id='fake/repo', + spec=spec, + diffusers_cfg={}, + dtype=torch.float32, + ) + + in_proj = transformer.in_proj + assert in_proj.__class__.__name__ == 'SDNQLinear' + assert in_proj.weight.dtype == torch.int8 + assert torch.equal(in_proj.weight.detach().cpu(), raw['model.diffusion_model.in_proj.weight']) + assert transformer.out_proj.__class__ is torch.nn.Linear + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_metadata_bare_names_end_to_end(): + """Marker-less container without a tensor prefix (official Comfy-Org + exports): metadata names match the bare keys and need no re-keying.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = {key[len('model.diffusion_model.'):]: value for key, value in comfy_fixture(dim).items()} + del raw['in_proj.comfy_quant'] + raw['in_proj.input_scale'] = torch.tensor(0.125, dtype=torch.float32) + layers = {'in_proj': {'format': 'int8_tensorwise'}} + write_fixture(raw, fd, path, metadata=quant_metadata(layers)) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, _ = nt.load( + local_file=path, + repo_id='fake/repo', + spec=spec, + diffusers_cfg={}, + dtype=torch.float32, + ) + + assert transformer.in_proj.__class__.__name__ == 'SDNQLinear' + assert torch.equal(transformer.in_proj.weight.detach().cpu(), raw['in_proj.weight']) + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_full_precision_mm_excluded_from_matmul(): + """Layers flagged full_precision_matrix_mult land on the config's + per-layer matmul exclusion list, which apply_sdnq_options_to_model + honors when the user enables quantized matmul.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + import json + raw = comfy_fixture(dim) + payload = {'format': 'int8_tensorwise', 'full_precision_matrix_mult': True} + raw['model.diffusion_model.in_proj.comfy_quant'] = torch.tensor(list(json.dumps(payload).encode()), dtype=torch.uint8) + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, _ = nt.load( + local_file=path, + repo_id='fake/repo', + spec=spec, + diffusers_cfg={}, + dtype=torch.float32, + ) + + assert 'in_proj.weight' in transformer.quantization_config.modules_to_not_use_matmul + assert transformer.in_proj.sdnq_dequantizer.use_quantized_matmul is False + finally: + if os.path.exists(path): + os.unlink(path) + + +def nvfp4_fixture(dim: int, with_marker: bool = True) -> tuple[dict, torch.Tensor]: + """A valid nvfp4 container for one marked linear, plus the reference + dequantized weight per the format definition: E2M1 decode * unswizzled + e4m3 block scale * fp32 global scale.""" + import json + groups = dim // 16 + gen = torch.Generator().manual_seed(7) + codes = torch.randint(0, 16, (dim, dim), generator=gen, dtype=torch.uint8) + block_scales = (torch.rand(dim, groups, generator=gen) * 2 + 0.5).to(torch.float8_e4m3fn) + global_scale = torch.tensor(0.0125, dtype=torch.float32) + lut = torch.tensor(E2M1_VALUES, dtype=torch.float32) + reference = lut[codes.long()].reshape(dim, groups, 16) * (block_scales.float() * global_scale).unsqueeze(-1) + reference = reference.reshape(dim, dim) + packed = torch.bitwise_or(torch.bitwise_left_shift(codes[:, 0::2], 4), codes[:, 1::2]) # even element in the high nibble + sd = { + 'model.diffusion_model.in_proj.weight': packed, + 'model.diffusion_model.in_proj.weight_scale': to_blocked_reference(block_scales), + 'model.diffusion_model.in_proj.weight_scale_2': global_scale, + 'model.diffusion_model.in_proj.bias': torch.randn(dim, generator=gen).to(torch.float16), + 'model.diffusion_model.out_proj.weight': torch.randn(dim, dim, generator=gen).to(torch.float16), + 'model.diffusion_model.out_proj.bias': torch.zeros(dim, dtype=torch.float16), + } + if with_marker: + marker = json.dumps({'format': 'nvfp4', 'group_size': 16, 'orig_dtype': 'torch.float16', 'orig_shape': [dim, dim]}) + sd['model.diffusion_model.in_proj.comfy_quant'] = torch.tensor(list(marker.encode()), dtype=torch.uint8) + return sd, reference + + +def test_load_comfy_nvfp4_end_to_end(): + """Full pipeline on an nvfp4 container: packed uint8 weights survive with + swapped nibble order, block scales unswizzle and fold with the global + scale into fp32 grouped scales, and the dequantized weight matches the + format reference exactly.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 32 + raw, reference = nvfp4_fixture(dim) + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, _ = nt.load( + local_file=path, + repo_id='fake/repo', + spec=spec, + diffusers_cfg={}, + dtype=torch.float32, + ) + + in_proj = transformer.in_proj + assert in_proj.__class__.__name__ == 'SDNQLinear' + dq = in_proj.sdnq_dequantizer + assert dq.weights_dtype == 'float4_e2m1fn' + assert dq.group_size == 16 + assert tuple(dq.quantized_weight_shape) == (dim, dim // 16, 16) + assert dq.re_quantize_for_matmul is True + assert in_proj.weight.dtype == torch.uint8 + assert tuple(in_proj.weight.shape) == (dim, dim // 2) + assert in_proj.scale.dtype == torch.float32 + assert tuple(in_proj.scale.shape) == (dim, dim // 16, 1) + + dequantized = dq(in_proj.weight, in_proj.scale, zero_point=None, svd_up=None, svd_down=None) + assert torch.equal(dequantized.detach().cpu(), reference) + + x = torch.randn(2, dim) + out = in_proj(x) + ref = torch.nn.functional.linear(x, reference, in_proj.bias.detach().cpu()) + assert torch.allclose(out.detach().cpu(), ref, atol=1e-5) + + assert transformer.out_proj.__class__ is torch.nn.Linear + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_nvfp4_metadata_form(): + """Marker-less nvfp4 (header metadata only, no orig_shape/group_size): + the format constant and module dimensions fill the gaps.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 32 + raw, reference = nvfp4_fixture(dim, with_marker=False) + layers = {'model.diffusion_model.in_proj': {'format': 'nvfp4'}} + write_fixture(raw, fd, path, metadata=quant_metadata(layers)) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, _ = nt.load( + local_file=path, + repo_id='fake/repo', + spec=spec, + diffusers_cfg={}, + dtype=torch.float32, + ) + + in_proj = transformer.in_proj + assert in_proj.__class__.__name__ == 'SDNQLinear' + assert in_proj.sdnq_dequantizer.weights_dtype == 'float4_e2m1fn' + dequantized = in_proj.sdnq_dequantizer(in_proj.weight, in_proj.scale, zero_point=None, svd_up=None, svd_down=None) + assert torch.equal(dequantized.detach().cpu(), reference) + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_nvfp4_orig_shape_mismatch_raises(): + """A marker whose orig_shape disagrees with the model config is a wrong + file for the class; reject so the base-repo fallback engages.""" + import json + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 32 + raw, _ = nvfp4_fixture(dim) + marker = json.dumps({'format': 'nvfp4', 'group_size': 16, 'orig_shape': [dim, dim * 2]}) + raw['model.diffusion_model.in_proj.comfy_quant'] = torch.tensor(list(marker.encode()), dtype=torch.uint8) + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + try: + nt.load(local_file=path, repo_id='fake/repo', spec=spec, diffusers_cfg={}, dtype=torch.float32) + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'orig_shape' in str(e) + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_detect_comfy_mixed_formats_raises(): + """One file mixing int8 and fp8 layers has no single SDNQ mapping; reject.""" + sd = { + 'a.weight': torch.zeros((4, 4), dtype=torch.int8), + 'a.comfy_quant': comfy_marker('int8_tensorwise'), + 'b.weight': torch.zeros((4, 4), dtype=torch.float8_e4m3fn), + 'b.comfy_quant': comfy_marker('float8_e4m3fn'), + } + try: + nt.detect_comfy_quant(sd, 'Test') + raise AssertionError('expected OverrideArchMismatch') + except nt.OverrideArchMismatch as e: + assert 'mixes formats' in str(e) + + +def test_load_comfy_marker_dtype_mismatch_raises(): + """A marker whose declared format does not match the stored weight dtype + (mislabeled container) must be rejected, not silently misinterpreted.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = comfy_fixture(dim) + raw['model.diffusion_model.in_proj.weight'] = torch.randn(dim, dim, dtype=torch.float16) # marker says int8 + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + raised = False + try: + nt.load(local_file=path, repo_id='fake/repo', spec=spec, diffusers_cfg={}) + except nt.OverrideArchMismatch as e: + raised = True + assert 'torch.int8' in str(e) and 'torch.float16' in str(e) + assert raised, 'expected OverrideArchMismatch' + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_unsupported_format_raises_mismatch(): + """A comfy_quant file in a format sdnext cannot adopt must surface as + OverrideArchMismatch so load_transformer falls back to the base repo.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = comfy_fixture(dim) + raw['model.diffusion_model.in_proj.comfy_quant'] = comfy_marker('float8_e4m3fn_scaled') + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + raised = False + try: + nt.load(local_file=path, repo_id='fake/repo', spec=spec, diffusers_cfg={}) + except nt.OverrideArchMismatch as e: + raised = True + assert 'float8_e4m3fn_scaled' in str(e) + assert raised, 'expected OverrideArchMismatch' + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_marker_for_unknown_module_raises_mismatch(): + """A marker naming a module the target class does not have means the file + belongs to a different arch; must fall back, not crash.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = comfy_fixture(dim) + raw['model.diffusion_model.ghost.weight'] = torch.zeros((dim, dim), dtype=torch.int8) + raw['model.diffusion_model.ghost.weight_scale'] = torch.tensor(1.0) + raw['model.diffusion_model.ghost.comfy_quant'] = comfy_marker('int8_tensorwise') + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + raised = False + try: + nt.load(local_file=path, repo_id='fake/repo', spec=spec, diffusers_cfg={}) + except nt.OverrideArchMismatch as e: + raised = True + assert 'ghost' in str(e) + assert raised, 'expected OverrideArchMismatch' + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_transformer_syncs_loaded_unet(): + """A full model load that consumes the UNET dropdown override must mark it + as loaded, so the queued sd_unet onchange callback does not trigger a + second, redundant full model reload.""" + from modules import sd_unet, shared + from pipelines import generic_transformer as gt + + fd, path = tempfile.mkstemp(suffix='.safetensors') + dim = 8 + raw = { + 'model.diffusion_model.in_proj.weight': torch.randn(dim, dim), + 'model.diffusion_model.in_proj.bias': torch.zeros(dim), + 'model.diffusion_model.out_proj.weight': torch.randn(dim, dim), + 'model.diffusion_model.out_proj.bias': torch.zeros(dim), + } + write_fixture(raw, fd, path) + + orig_unet_opt = shared.opts.sd_unet + orig_loaded = sd_unet.loaded_unet + sd_unet.unet_dict['mock-unet'] = path + shared.opts.data['sd_unet'] = 'mock-unet' + sd_unet.loaded_unet = None + try: + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer = gt.load_transformer('fake/repo', cls_name=MockMiniTransformer, native_spec=spec) + assert transformer is not None + assert sd_unet.loaded_unet == 'mock-unet', f'override consumed but loaded_unet={sd_unet.loaded_unet}' + finally: + sd_unet.unet_dict.pop('mock-unet', None) + shared.opts.data['sd_unet'] = orig_unet_opt + sd_unet.loaded_unet = orig_loaded + if os.path.exists(path): + os.unlink(path) + + +class MockFusedAttention(torch.nn.Module): + """Split-attention module tree matching Ideogram4Transformer2DModel's + naming (to_q/to_k/to_v + to_out ModuleList), fed by fused checkpoints.""" + + def __init__(self, dim: int): + super().__init__() + self.to_q = torch.nn.Linear(dim, dim, bias=False) + self.to_k = torch.nn.Linear(dim, dim, bias=False) + self.to_v = torch.nn.Linear(dim, dim, bias=False) + self.to_out = torch.nn.ModuleList([torch.nn.Linear(dim, dim, bias=False), torch.nn.Dropout(0.0)]) + + +class MockFusedBlock(torch.nn.Module): + def __init__(self, dim: int): + super().__init__() + self.attention = MockFusedAttention(dim) + + +class MockFusedTransformer(torch.nn.Module): + @classmethod + def from_config(cls, config: dict, **kwargs) -> 'MockFusedTransformer': + return cls(dim=config['dim']) + + def __init__(self, dim: int): + super().__init__() + self.layers = torch.nn.ModuleList([MockFusedBlock(dim)]) + self.input_proj = torch.nn.Linear(dim, dim) + + +def fused_spec(): + from pipelines.ideogram import convert_ideogram4_transformer_checkpoint + return nt.TransformerSpec( + cls=MockFusedTransformer, + converter=convert_ideogram4_transformer_checkpoint, + converter_handles_quant=True, + ) + + +def fused_fixture(dim: int, quantized: bool = True) -> dict: + if quantized: + qkv = torch.randint(-128, 127, (3 * dim, dim), dtype=torch.int8) + else: + qkv = torch.randn(3 * dim, dim, dtype=torch.float16) + raw = { + 'model.diffusion_model.layers.0.attention.qkv.weight': qkv, + 'model.diffusion_model.layers.0.attention.o.weight': torch.randn(dim, dim, dtype=torch.float16), + 'model.diffusion_model.input_proj.weight': torch.randn(dim, dim, dtype=torch.float16), + 'model.diffusion_model.input_proj.bias': torch.zeros(dim, dtype=torch.float16), + } + if quantized: + raw['model.diffusion_model.layers.0.attention.qkv.weight_scale'] = torch.rand(3 * dim, 1, dtype=torch.float32) + raw['model.diffusion_model.layers.0.attention.qkv.comfy_quant'] = comfy_marker('int8_tensorwise') + return raw + + +def test_load_fused_comfy_end_to_end(): + """Quant-aware converter + comfy adoption: fused int8 qkv with row-wise + scales lands as three SDNQ linears holding the exact row slices.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = fused_fixture(dim, quantized=True) + write_fixture(raw, fd, path) + with ComfyTestEnv(dim): + transformer, _ = nt.load(local_file=path, repo_id='fake/repo', spec=fused_spec(), diffusers_cfg={}, dtype=torch.float32) + + attn = transformer.layers[0].attention + fused_w = raw['model.diffusion_model.layers.0.attention.qkv.weight'] + fused_s = raw['model.diffusion_model.layers.0.attention.qkv.weight_scale'] + for i, name in enumerate(('to_q', 'to_k', 'to_v')): + layer = getattr(attn, name) + assert layer.__class__.__name__ == 'SDNQLinear', f'{name} is {layer.__class__.__name__}' + assert layer.weight.dtype == torch.int8 + assert torch.equal(layer.weight.detach().cpu(), fused_w[i * dim:(i + 1) * dim]) + assert tuple(layer.scale.shape) == (dim, 1), f'{name} scale shape {layer.scale.shape}' + assert torch.equal(layer.scale.detach().cpu(), fused_s[i * dim:(i + 1) * dim]) + expected = fused_w[i * dim:(i + 1) * dim].float() * fused_s[i * dim:(i + 1) * dim] + dequantized = layer.sdnq_dequantizer(layer.weight, layer.scale, zero_point=None, svd_up=None, svd_down=None) + assert torch.equal(dequantized.detach().cpu(), expected) + # unmarked o.weight passes through the rename as a plain Linear + assert attn.to_out[0].__class__ is torch.nn.Linear + assert torch.allclose(attn.to_out[0].weight.detach().cpu(), raw['model.diffusion_model.layers.0.attention.o.weight'].float()) + assert transformer.input_proj.__class__ is torch.nn.Linear + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_fused_bf16_end_to_end(): + """Converter-first on a plain float fused file: no markers, standard load + path, split weights land on the class-native linears.""" + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = fused_fixture(dim, quantized=False) + write_fixture(raw, fd, path) + with ComfyTestEnv(dim): + transformer, _ = nt.load(local_file=path, repo_id='fake/repo', spec=fused_spec(), diffusers_cfg={}, dtype=torch.float32) + + attn = transformer.layers[0].attention + fused_w = raw['model.diffusion_model.layers.0.attention.qkv.weight'] + for i, name in enumerate(('to_q', 'to_k', 'to_v')): + layer = getattr(attn, name) + assert layer.__class__ is torch.nn.Linear + assert torch.allclose(layer.weight.detach().cpu(), fused_w[i * dim:(i + 1) * dim].float()) + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_fused_convrot_end_to_end(): + """Fused qkv with a convrot marker: the converter duplicates the marker to + the three split layers, each of which loads with hadamard geometry. Row + slicing commutes with the in-features rotation, so slices stay lossless.""" + import json as json_mod + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim, group_size = 8, 4 + raw = fused_fixture(dim, quantized=True) + payload = json_mod.dumps({'format': 'int8_tensorwise', 'convrot': True, 'convrot_groupsize': group_size, 'per_row': True}) + raw['model.diffusion_model.layers.0.attention.qkv.comfy_quant'] = torch.tensor(list(payload.encode()), dtype=torch.uint8) + raw['model.diffusion_model.layers.0.attention.qkv.weight_scale'] = torch.rand(3 * dim, 1, dtype=torch.float32) + write_fixture(raw, fd, path) + with ComfyTestEnv(dim): + transformer, _ = nt.load(local_file=path, repo_id='fake/repo', spec=fused_spec(), diffusers_cfg={}, dtype=torch.float32) + attn = transformer.layers[0].attention + for name in ('to_q', 'to_k', 'to_v'): + dq = getattr(attn, name).sdnq_dequantizer + assert dq.use_hadamard is True, f'{name} lost the convrot flag' + assert dq.hadamard_group_size == group_size + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_build_component_comfy_skips_converter_when_not_quant_aware(): + """With converter_handles_quant=False (the default for every other arch), + a comfy state dict must reach the prequantized path without the converter + ever running; a crashing converter proves it was not invoked.""" + dim = 8 + raw = comfy_fixture(dim) + sd = {k[len('model.diffusion_model.'):]: v for k, v in raw.items()} + with ComfyTestEnv(dim): + component = nt.build_component( + component_name='transformer', + state_dict=sd, + config={'dim': dim}, + cls=MockMiniTransformer, + converter=crashing_converter, + acceptable_missing=('rope.',), + quant_args={}, + quant_type='SDNQConfig', + dtype=torch.float32, + ) + assert component.in_proj.__class__.__name__ == 'SDNQLinear' + + +def test_load_transformer_secondary_slot_syncs_tracker(): + """The secondary slot consumes sd_unet_secondary and syncs its own + tracker without touching the primary slot.""" + from modules import sd_unet, shared + from pipelines import generic_transformer as gt + + fd, path = tempfile.mkstemp(suffix='.safetensors') + dim = 8 + raw = { + 'model.diffusion_model.in_proj.weight': torch.randn(dim, dim), + 'model.diffusion_model.in_proj.bias': torch.zeros(dim), + 'model.diffusion_model.out_proj.weight': torch.randn(dim, dim), + 'model.diffusion_model.out_proj.bias': torch.zeros(dim), + } + write_fixture(raw, fd, path) + + orig_primary_opt = shared.opts.sd_unet + orig_secondary_opt = shared.opts.sd_unet_secondary + orig_primary = sd_unet.loaded_unet + orig_secondary = sd_unet.loaded_unet_secondary + sd_unet.unet_dict['mock-unet-2'] = path + shared.opts.data['sd_unet'] = 'Default' + shared.opts.data['sd_unet_secondary'] = 'mock-unet-2' + sd_unet.loaded_unet = None + sd_unet.loaded_unet_secondary = None + try: + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer = gt.load_transformer('fake/repo', cls_name=MockMiniTransformer, native_spec=spec, override_slot='secondary') + assert transformer is not None + assert sd_unet.loaded_unet_secondary == 'mock-unet-2' + assert sd_unet.loaded_unet is None, 'primary tracker must stay untouched' + finally: + sd_unet.unet_dict.pop('mock-unet-2', None) + shared.opts.data['sd_unet'] = orig_primary_opt + shared.opts.data['sd_unet_secondary'] = orig_secondary_opt + sd_unet.loaded_unet = orig_primary + sd_unet.loaded_unet_secondary = orig_secondary + if os.path.exists(path): + os.unlink(path) + + +def regular_hadamard(n: int) -> torch.Tensor: + """Regular Hadamard construction the ConvRot format and SDNQ share: + 4x4 base, Kronecker recursion, 1/sqrt(n) normalization. Symmetric and + involutory, so rotation and inverse are the same matrix.""" + h4 = torch.tensor([[1., 1., 1., -1.], [1., 1., -1., 1.], [1., -1., 1., 1.], [-1., 1., 1., 1.]]) + h = h4 + size = 4 + while size < n: + h = torch.kron(h, h4) + size *= 4 + return h / (n ** 0.5) + + +def comfy_convrot_quantize(weight: torch.Tensor, group_size: int): + """Reference ConvRot int8 quantizer (mirrors the ComfyUI runtime): rotate + grouped in-features by the regular Hadamard, then row-wise symmetric int8.""" + h = regular_hadamard(group_size) + out_f, in_f = weight.shape + rotated = (weight.reshape(out_f, -1, group_size) @ h.T).reshape(out_f, in_f) + scale = rotated.abs().amax(dim=-1, keepdim=True) / 127 + q = rotated.div(scale).round().clamp(-128, 127).to(torch.int8) + return q, scale + + +def test_load_comfy_convrot_end_to_end(): + """ConvRot parity: a layer quantized with the reference ConvRot math + loads as an SDNQ hadamard layer whose dequant matches the reference dequant + and recovers the original weight within int8 quantization error. The plain + second layer proves per-layer mixing within one file.""" + import json as json_mod + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim, group_size = 8, 4 + original = torch.randn(dim, dim) + q, scale = comfy_convrot_quantize(original, group_size) + marker = json_mod.dumps({'format': 'int8_tensorwise', 'convrot': True, 'convrot_groupsize': group_size, 'per_row': True}) + raw = { + 'model.diffusion_model.in_proj.weight': q, + 'model.diffusion_model.in_proj.weight_scale': scale, + 'model.diffusion_model.in_proj.comfy_quant': torch.tensor(list(marker.encode()), dtype=torch.uint8), + 'model.diffusion_model.in_proj.bias': torch.zeros(dim, dtype=torch.float16), + 'model.diffusion_model.out_proj.weight': torch.randint(-128, 127, (dim, dim), dtype=torch.int8), + 'model.diffusion_model.out_proj.weight_scale': torch.tensor(0.03125, dtype=torch.float32), + 'model.diffusion_model.out_proj.comfy_quant': comfy_marker('int8_tensorwise'), + 'model.diffusion_model.out_proj.bias': torch.zeros(dim, dtype=torch.float16), + } + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + transformer, _ = nt.load(local_file=path, repo_id='fake/repo', spec=spec, diffusers_cfg={}, dtype=torch.float32) + + in_proj = transformer.in_proj + dq = in_proj.sdnq_dequantizer + assert dq.use_hadamard is True + assert dq.hadamard_group_size == group_size + assert tuple(in_proj.scale.shape) == (dim, 1) + + dequantized = dq(in_proj.weight, in_proj.scale, zero_point=None, svd_up=None, svd_down=None).detach().cpu() + h = regular_hadamard(group_size) + reference = ((q.float() * scale).reshape(dim, -1, group_size) @ h.T).reshape(dim, dim) + assert torch.allclose(dequantized, reference, atol=1e-5), 'SDNQ hadamard dequant diverges from the ConvRot reference' + assert torch.allclose(dequantized, original, atol=0.15), 'dequant does not recover the original weight' + + # plain layer in the same file stays rotation-free + assert transformer.out_proj.sdnq_dequantizer.use_hadamard is False + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_load_comfy_convrot_nondivisible_falls_back(): + """A convrot group size that does not divide in_features cannot be undone; + the file must fall back to the base repo.""" + import json as json_mod + fd, path = tempfile.mkstemp(suffix='.safetensors') + try: + dim = 8 + raw = comfy_fixture(dim) + marker = json_mod.dumps({'format': 'int8_tensorwise', 'convrot': True, 'convrot_groupsize': 16}) + raw['model.diffusion_model.in_proj.comfy_quant'] = torch.tensor(list(marker.encode()), dtype=torch.uint8) + write_fixture(raw, fd, path) + + with ComfyTestEnv(dim): + spec = nt.TransformerSpec(cls=MockMiniTransformer) + raised = False + try: + nt.load(local_file=path, repo_id='fake/repo', spec=spec, diffusers_cfg={}) + except nt.OverrideArchMismatch as e: + raised = True + assert 'does not divide' in str(e) + assert raised, 'expected OverrideArchMismatch' + finally: + if os.path.exists(path): + os.unlink(path) + + +def test_build_component_comfy_preempts_sdnq_fresh_quant(): + """When SDNQ on-load quant settings are active (quant_type=SDNQConfig), a + comfy_quant file must still take the pre-quantized path: fresh quant of + int8 data would corrupt it. quant_args={} proves the comfy branch never + reaches build_component_quantized (which requires a quantization_config).""" + dim = 8 + raw = comfy_fixture(dim) + sd = {k[len('model.diffusion_model.'):]: v for k, v in raw.items()} + with ComfyTestEnv(dim): + component = nt.build_component( + component_name='transformer', + state_dict=sd, + config={'dim': dim}, + cls=MockMiniTransformer, + converter=None, + acceptable_missing=('rope.',), + quant_args={}, + quant_type='SDNQConfig', + dtype=torch.float32, + ) + assert component.in_proj.__class__.__name__ == 'SDNQLinear' + assert component.in_proj.weight.dtype == torch.int8 + + # ============================================================ # Run # ============================================================ def run_all(): + log.warning('=== drop_companion_keys ===') + cat = category('companion') + for fn in [ + test_drop_companion_keys_no_companions_pass_through, + test_drop_companion_keys_filters_all_in_one_layout, + test_drop_companion_keys_raises_when_nothing_left, + test_drop_companion_keys_empty_prefix_tuple_no_op, + test_drop_then_strip_all_in_one_layout, + ]: + run_test(cat, fn) + log.warning('=== strip_prefix ===') cat = category('strip') for fn in [ @@ -811,6 +2250,56 @@ def run_all(): ]: run_test(cat, fn) + log.warning('=== comfy_quant detection / remap ===') + cat = category('comfy') + for fn in [ + test_detect_comfy_no_markers_returns_none, + test_detect_comfy_valid_markers, + test_detect_comfy_unsupported_format_raises, + test_detect_comfy_malformed_marker_raises, + test_detect_comfy_convrot_accepted, + test_detect_comfy_convrot_bad_groupsize_raises, + test_detect_comfy_marker_missing_format_field_raises, + test_remap_comfy_renames_and_reshapes_scale, + test_remap_comfy_passes_unmarked_keys_verbatim, + test_remap_comfy_does_not_mutate_input, + test_remap_comfy_drops_input_scale, + test_read_quant_metadata_absent_returns_none, + test_read_quant_metadata_parses_layers, + test_read_quant_metadata_malformed_raises, + test_read_quant_metadata_non_dict_layers_raises, + test_transcode_quant_metadata_synthesizes_markers, + test_transcode_quant_metadata_header_wins, + test_transcode_quant_metadata_no_matches_is_noop, + ]: + run_test(cat, fn) + + log.warning('=== nvfp4 codec / unswizzle / load ===') + cat = category('nvfp4') + for fn in [ + test_unswizzle_block_scales_roundtrip, + test_nvfp4_codec_ocp_table, + test_nvfp4_pack_ocp_grid_roundtrip, + test_detect_comfy_nvfp4_marker_accepted, + test_detect_comfy_nvfp4_bad_group_size_raises, + test_detect_comfy_nvfp4_convrot_raises, + test_load_comfy_nvfp4_end_to_end, + test_load_comfy_nvfp4_metadata_form, + test_load_comfy_nvfp4_orig_shape_mismatch_raises, + ]: + run_test(cat, fn) + + log.warning('=== model_probe quant detection ===') + cat = category('probe') + for fn in [ + test_probe_detects_header_quant_metadata, + test_probe_resolves_nvfp4_from_weight_dtype, + test_probe_fp8_markers_despite_u8_noise, + test_probe_int8_markers, + test_probe_plain_file_no_quant, + ]: + run_test(cat, fn) + log.warning('=== noop_converter detection ===') cat = category('noop') for fn in [ @@ -871,6 +2360,45 @@ def run_all(): ]: run_test(cat, fn) + log.warning('=== comfy_quant load ===') + cat = category('comfy_load') + for fn in [ + test_load_comfy_int8_end_to_end, + test_load_comfy_fp8_end_to_end, + test_load_comfy_fp8_remaps_storage_when_compile_unsupported, + test_load_comfy_metadata_end_to_end, + test_load_comfy_metadata_bare_names_end_to_end, + test_load_comfy_full_precision_mm_excluded_from_matmul, + test_detect_comfy_mixed_formats_raises, + test_load_comfy_marker_dtype_mismatch_raises, + test_load_comfy_unsupported_format_raises_mismatch, + test_load_comfy_marker_for_unknown_module_raises_mismatch, + test_load_comfy_convrot_end_to_end, + test_load_comfy_convrot_nondivisible_falls_back, + test_load_transformer_syncs_loaded_unet, + test_load_transformer_secondary_slot_syncs_tracker, + test_build_component_comfy_preempts_sdnq_fresh_quant, + test_build_component_comfy_skips_converter_when_not_quant_aware, + ]: + run_test(cat, fn) + + log.warning('=== ideogram4 converter / fused load ===') + cat = category('ideogram4') + for fn in [ + test_ideogram4_converter_splits_fused_qkv_weight, + test_ideogram4_converter_splits_rowwise_scale, + test_ideogram4_converter_scalar_scale_copied_not_sliced, + test_ideogram4_converter_duplicates_marker, + test_ideogram4_converter_renames_o_with_sidecars, + test_ideogram4_converter_passthrough, + test_ideogram4_converter_defensive_bias_split, + test_ideogram4_converter_does_not_mutate_input, + test_load_fused_comfy_end_to_end, + test_load_fused_bf16_end_to_end, + test_load_fused_convrot_end_to_end, + ]: + run_test(cat, fn) + log.warning('=== Results ===') total_passed = 0 total_failed = 0 diff --git a/test/test-zimage-native-adapters.py b/test/test-zimage-native-adapters.py index 6f958161b..77004d18e 100644 --- a/test/test-zimage-native-adapters.py +++ b/test/test-zimage-native-adapters.py @@ -125,6 +125,7 @@ MLP_HIDDEN = int(HIDDEN / 3 * 8) # 256, matches ZImageTransformerBlock FeedFor ADALN_OUT = 4 * HIDDEN # 384, matches Z-Image adaLN_modulation N_LAYERS = 2 # main transformer blocks N_REFINER = 1 # noise_refiner / context_refiner blocks +PATCH_KEY = "2-1" # the single all_x_embedder / all_final_layer key both variants build # pylint: disable=attribute-defined-outside-init @@ -184,6 +185,26 @@ def build_mock_transformer(): transformer.layers = torch.nn.ModuleList([build_zimage_block(modulation=False) for _ in range(N_LAYERS)]) transformer.noise_refiner = torch.nn.ModuleList([build_zimage_block(modulation=True) for _ in range(N_REFINER)]) transformer.context_refiner = torch.nn.ModuleList([build_zimage_block(modulation=True) for _ in range(N_REFINER)]) + # Non-block targets. all_x_embedder / all_final_layer are ModuleDicts keyed by + # "{patch_size}-{f_patch_size}"; both shipped variants build the single key below. + final_layer = _Holder() + final_layer.linear = torch.nn.Linear(HIDDEN, HIDDEN, bias=True) + final_layer.adaLN_modulation = torch.nn.Sequential( + torch.nn.SiLU(), + torch.nn.Linear(HIDDEN, ADALN_OUT, bias=True), + ) + transformer.all_x_embedder = torch.nn.ModuleDict({PATCH_KEY: torch.nn.Linear(HIDDEN, HIDDEN, bias=True)}) + transformer.all_final_layer = torch.nn.ModuleDict({PATCH_KEY: final_layer}) + transformer.t_embedder = _Holder() + transformer.t_embedder.mlp = torch.nn.Sequential( + torch.nn.Linear(HIDDEN, HIDDEN, bias=True), + torch.nn.SiLU(), + torch.nn.Linear(HIDDEN, HIDDEN, bias=True), + ) + transformer.cap_embedder = torch.nn.Sequential( + torch.nn.RMSNorm(HIDDEN), + torch.nn.Linear(HIDDEN, HIDDEN, bias=True), + ) return transformer @@ -313,6 +334,24 @@ def sd_lokr_legacy_fused_qkv(): } +def sd_lokr_lycoris_style(): + """LyCORIS-standalone LoKR (``lycoris_`` + underscored diffusers path). + + The prefix is resolved by the universal passthrough in native_adapter, not + by anything zimage-specific. ``to_out.0`` exercises the verbatim + round-trip where a naive underscore-to-dot expansion would corrupt the + ModuleList index. + """ + return { + 'lycoris_layers_0_attention_to_q.lokr_w1': torch.randn(LOKR_W1_DIM, LOKR_W1_DIM), + 'lycoris_layers_0_attention_to_q.lokr_w2': torch.randn(HIDDEN // LOKR_W1_DIM, HIDDEN // LOKR_W1_DIM), + 'lycoris_layers_0_attention_to_q.alpha': torch.tensor(float(LOKR_W1_DIM)), + 'lycoris_layers_1_attention_to_out_0.lokr_w1': torch.randn(LOKR_W1_DIM, LOKR_W1_DIM), + 'lycoris_layers_1_attention_to_out_0.lokr_w2': torch.randn(HIDDEN // LOKR_W1_DIM, HIDDEN // LOKR_W1_DIM), + 'lycoris_layers_1_attention_to_out_0.alpha': torch.tensor(float(LOKR_W1_DIM)), + } + + def sd_loha_bfl_proj(): """LoHA on attention.to_out.0 (non-fused; LoHA on fused qkv is skipped by the loader).""" return { @@ -599,6 +638,112 @@ def test_lokr_legacy_fused_qkv_chunked(): return True +def test_lokr_lycoris_prefix_passthrough(): + """lycoris_ keys load via the universal passthrough (hoisted, not zimage-specific).""" + net = _load_via(Z.try_load_lokr, sd_lokr_lycoris_style()) + assert net is not None and len(net.modules) == 2, f'got {net.modules if net else None}' + expected = { + 'lora_transformer_layers_0_attention_to_q', + 'lora_transformer_layers_1_attention_to_out_0', + } + assert set(net.modules) == expected, f'got {set(net.modules)}' + for mod in net.modules.values(): + assert isinstance(mod, network_lokr.NetworkModuleLokr) + return True + + +def test_full_diff_chain(): + """Full-diff extraction loads through the chain (RedLSP-shaped). + + Verifies the try_load chain includes try_load_full: diff+diff_b on the + legacy attention.out alias binds; the fused attention.qkv diff group is + skipped with a warning (no chunk variant for the Full family). + """ + sd = { + 'diffusion_model.layers.0.attention.out.diff': torch.randn(HIDDEN, HIDDEN), + 'diffusion_model.layers.0.attention.out.diff_b': torch.randn(HIDDEN), + 'diffusion_model.layers.0.attention.qkv.diff': torch.randn(3 * HIDDEN, HIDDEN), + } + net = _load_via(Z.try_load, sd) + assert net is not None and len(net.modules) == 1, f'got {net.modules if net else None}' + assert 'lora_transformer_layers_0_attention_to_out_0' in net.modules, f'got {set(net.modules)}' + mod = next(iter(net.modules.values())) + updown, ex_bias = mod.calc_updown(mod.sd_module.weight) + assert tuple(updown.shape) == (HIDDEN, HIDDEN) and torch.isfinite(updown).all() + assert ex_bias is not None and tuple(ex_bias.shape) == (HIDDEN,) + return True + + +def test_full_stamps_norm_targets(): + """A Full adapter on a norm target binds AND applies. + + assign_network_names_to_compvis_modules puts norms in the mapping but never + stamps network_layer_name on them, and the apply pass keys off that + attribute: without loader-local stamping the module binds and then silently + never applies. Regression for the RedLSP extraction, which bound 308 + modules and applied only 172. + """ + sd = { + 'diffusion_model.layers.0.attention_norm1.diff': torch.randn(HIDDEN), + 'diffusion_model.layers.0.attention.q_norm.diff': torch.randn(HEAD_DIM), + } + net = _load_via(Z.try_load, sd) + assert net is not None and len(net.modules) == 2, f'got {sorted(net.modules) if net else None}' + expected = {'lora_transformer_layers_0_attention_norm1', 'lora_transformer_layers_0_attention_norm_q'} + assert set(net.modules) == expected, f'got {set(net.modules)}' + for key, mod in net.modules.items(): + assert getattr(mod.sd_module, 'network_layer_name', None) == key, \ + f'{key}: host module not stamped, the apply pass will skip it' + return True + + +def test_resolve_targets_norm_aliases_and_extra(): + """qk-norm renames and the ModuleDict-keyed non-block targets.""" + cases = [ + (('diffusion_model.', 'layers.0.attention.q_norm'), 'layers.0.attention.norm_q'), + (('diffusion_model.', 'layers.3.attention.k_norm'), 'layers.3.attention.norm_k'), + (('lora_unet_', 'layers_0_attention_q_norm'), 'layers_0_attention_norm_q'), + ((None, 'noise_refiner.0.attention.k_norm'), 'noise_refiner.0.attention.norm_k'), + ] + for (prefix, base), expected in cases: + targets = Z.resolve_targets(prefix, base) + assert targets == [(expected, None)], f'({prefix}, {base}) -> {targets}' + # the patch key comes from the live model's all_x_embedder ModuleDict + install_mock_pipe() + for base, expected in [ + ('x_embedder', f'all_x_embedder.{PATCH_KEY}'), + ('final_layer.linear', f'all_final_layer.{PATCH_KEY}.linear'), + ('final_layer.adaLN_modulation.1', f'all_final_layer.{PATCH_KEY}.adaLN_modulation.1'), + ]: + targets = Z.resolve_targets('diffusion_model.', base) + assert targets == [(expected, None)], f'{base} -> {targets}' + kohya = Z.resolve_targets('lora_unet_', base.replace('.', '_')) + assert kohya == [(expected, None)], f'kohya {base} -> {kohya}' + return True + + +def test_full_extra_modules_bind(): + """x_embedder and final_layer bind through the ModuleDict paths.""" + sd = { + 'diffusion_model.x_embedder.diff': torch.randn(HIDDEN, HIDDEN), + 'diffusion_model.final_layer.linear.diff': torch.randn(HIDDEN, HIDDEN), + 'diffusion_model.final_layer.adaLN_modulation.1.diff': torch.randn(ADALN_OUT, HIDDEN), + 'diffusion_model.t_embedder.mlp.0.diff': torch.randn(HIDDEN, HIDDEN), + 'diffusion_model.cap_embedder.1.diff': torch.randn(HIDDEN, HIDDEN), + } + net = _load_via(Z.try_load, sd) + assert net is not None and len(net.modules) == 5, f'got {sorted(net.modules) if net else None}' + expected = { + f'lora_transformer_all_x_embedder_{PATCH_KEY}', + f'lora_transformer_all_final_layer_{PATCH_KEY}_linear', + f'lora_transformer_all_final_layer_{PATCH_KEY}_adaLN_modulation_1', + 'lora_transformer_t_embedder_mlp_0', + 'lora_transformer_cap_embedder_1', + } + assert set(net.modules) == expected, f'got {set(net.modules)}' + return True + + def test_loha_bfl_proj(): """BFL LoHA on a non-fused proj target binds via NetworkModuleHada.""" net = _load_via(Z.try_load_loha, sd_loha_bfl_proj()) @@ -714,7 +859,8 @@ def run_tests(): t0 = time.time() log.warning('=== Parsing primitives ===') - for fn in [test_parse_key_all_prefixes, test_marker_disambiguation]: + for fn in [test_parse_key_all_prefixes, test_marker_disambiguation, + test_resolve_targets_norm_aliases_and_extra]: run_test(CAT_PARSE, fn) log.warning('=== Loaders ===') @@ -729,6 +875,10 @@ def run_tests(): test_lora_dora_threading, test_lokr_bfl_adaln, test_lokr_legacy_fused_qkv_chunked, + test_lokr_lycoris_prefix_passthrough, + test_full_diff_chain, + test_full_stamps_norm_targets, + test_full_extra_modules_bind, test_loha_bfl_proj, test_loha_legacy_fused_qkv_chunked, test_oft_lycoris_no_npe, diff --git a/ui/authWrap.ts b/ui/authWrap.ts index 641393230..edb16fe57 100644 --- a/ui/authWrap.ts +++ b/ui/authWrap.ts @@ -7,6 +7,7 @@ interface TokenResponse { let user: string | undefined; let token: string | undefined; +let baseURL: string | undefined; export async function getToken(): Promise<{ user: string | undefined; token: string | undefined }> { if (token === undefined || user === undefined) { @@ -38,6 +39,11 @@ export async function authFetch(url: RequestInfo | URL, options: RequestInit = { error('fetch', { status: res?.status || 503, url, user, token, error: err }); } } + if (!baseURL) { + // baseURL = `${window.location.protocol}//${window.location.host}:${window.location.port}`; + baseURL = window.location.origin; + log('origin', baseURL); + } return res; } window.authFetch = authFetch; diff --git a/ui/css/sdnext.css b/ui/css/sdnext.css index ae22fc1bd..1cc088b3b 100644 --- a/ui/css/sdnext.css +++ b/ui/css/sdnext.css @@ -1852,7 +1852,7 @@ background: var(--background-color) #tab-gallery-files gallery-file { /* Add a vertical gutter between items (left/right), matching existing small row spacing */ - display: inline-block !important; + display: inline-block; margin-right: 0.2em; vertical-align: top; /* keep rows aligned on the top edge */ } @@ -2286,6 +2286,16 @@ div:has(>#tab-gallery-folders) { filter: blur(0); } +#logMonitor { + width: stretch; +} + +#logMonitorData { + height: 12vh; + overflow-y: scroll; + overflow-x: auto; +} + .disabled-look textarea { opacity: 0.4; pointer-events: none; diff --git a/ui/dist/sdnext.mjs b/ui/dist/sdnext.mjs index fddf99727..ff4294a7c 100644 --- a/ui/dist/sdnext.mjs +++ b/ui/dist/sdnext.mjs @@ -9883,6 +9883,7 @@ window.xhrPost = xhrPost; // ui/authWrap.ts var user; var token; +var baseURL; async function getToken() { if (token === void 0 || user === void 0) { const res = await fetch(`${window.subpath}/token`); @@ -9912,6 +9913,10 @@ async function authFetch(url2, options = {}) { error("fetch", { status: res?.status || 503, url: url2, user, token, error: err }); } } + if (!baseURL) { + baseURL = window.location.origin; + log("origin", baseURL); + } return res; } window.authFetch = authFetch; @@ -10152,7 +10157,7 @@ async function initTableSorter() { async function deleteFile(filename) { if (!filename) return; if (!confirm(`Are you sure you want to delete the object - This action cannot be undone? Object: ${filename}`)) return; - const res = await authFetch(`${window.api}/delete-file?file=${encodeURIComponent(filename)}`); + const res = await authFetch(`${window.api}/delete-file?file=${encodeURIComponent(filename)}`, { method: "DELETE" }); if (!res || res.status !== 200) { error("FileDelete", { file: filename, status: res?.status, statusText: res?.statusText }); return; @@ -10308,9 +10313,13 @@ async function setupControlUI() { // ui/extraNetworks.ts var activePromptTextarea = {}; +var selectedNetworks = {}; var sortVal = -1; var totalCards = -1; var lastTab = "control"; +function getSelectedNetworks() { + return selectedNetworks; +} var getENActiveTab = () => { let tabName = ""; if (gradioApp().getElementById("txt2img_prompt")?.checkVisibility() || gradioApp().getElementById("txt2img_generate")?.checkVisibility()) tabName = "txt2img"; @@ -10539,6 +10548,7 @@ function sortExtraNetworks(fixed = "no") { } async function markSelectedCards(selected, page = "") { log("markSelectedCards", selected, page); + selectedNetworks[page] = selected; gradioApp().querySelectorAll(".extra-network-cards .card").forEach((el2) => { if (page.length > 0 && el2.dataset.page !== page) return; if (selected.includes(el2.dataset.name) || selected.includes(el2.dataset.short)) el2.classList.add("card-selected"); @@ -10851,6 +10861,7 @@ window.applyStyles = applyStyles; window.closeDetailsEN = closeDetailsEN; window.getENActivePage = getENActivePage; window.getCardDetails = getCardDetails; +window.getSelectedNetworks = getSelectedNetworks; window.sortExtraNetworks = sortExtraNetworks; window.refeshDetailsEN = refeshDetailsEN; window.extraNetworksSearchButton = extraNetworksSearchButton; @@ -10965,7 +10976,7 @@ var progressTimeout = 180; var startTimeout = 5; function setRefreshInterval() { refreshInterval = window.opts.live_preview_refresh_period || 500; - log("refreshInterval", document.visibilityState, refreshInterval); + log("refreshInterval", { visibile: document.visibilityState, interval: refreshInterval }); document.addEventListener("visibilitychange", () => { if (window.opts.live_preview_require_focus !== false && document.hidden) refreshInterval = Math.max(2500, window.opts.live_preview_refresh_period || 1e3); else refreshInterval = window.opts.live_preview_refresh_period || 1e3; @@ -11287,14 +11298,13 @@ function setFontSize(val, old) { rootStyle.setProperty("--text-xxl", `${nextSize + 3}px`); appliedFontSize = nextSize; const t1 = performance.now(); - log("setFontSize", nextSize, `time=${Math.round(t1 - t0)}`); - timer("setFontSize", t1 - t0); + log("setFontSize", { size: nextSize, time: Math.round(t1 - t0) }); }); } function switchToTab(tab) { const tabs = Array.from(gradioApp().querySelectorAll("#tabs > .tab-nav > button")); const btn = tabs?.find((t) => t.innerText === tab); - log("switchToTab", tab); + log("switchToTab", { tab }); if (btn) btn.click(); } function switch_to_txt2img(...args) { @@ -11662,8 +11672,12 @@ function getDesiredCheckpointName() { } function selectUNet(name) { desiredUNetName = name; - gradioApp().getElementById("change_unet").click(); - log(`selectUNet: ${desiredUNetName}`); + const tabName = getENActiveTab(); + const btnModel = gradioApp().getElementById(`${tabName}_extra_model`); + const isSecondary = btnModel && btnModel.classList.contains("toolbutton-selected"); + if (isSecondary) gradioApp().getElementById("change_unet_secondary").click(); + else gradioApp().getElementById("change_unet").click(); + log(`selectUNet ${isSecondary ? "secondary" : "primary"}: ${desiredUNetName}`); markSelectedCards([desiredUNetName], "unet"); } function selectReference(name) { @@ -11988,14 +12002,11 @@ var logErrors = 0; var logConnected = false; function dateToStr(ts) { const dt = new Date(1e3 * ts); - const year = dt.getFullYear(); - const mo = String(dt.getMonth() + 1).padStart(2, "0"); - const day = String(dt.getDate()).padStart(2, "0"); const hour = String(dt.getHours()).padStart(2, "0"); const min = String(dt.getMinutes()).padStart(2, "0"); const sec = String(dt.getSeconds()).padStart(2, "0"); const ms = String(dt.getMilliseconds()).padStart(3, "0"); - const s = `${year}-${mo}-${day} ${hour}:${min}:${sec}.${ms}`; + const s = `${hour}:${min}:${sec}.${ms}`; return s; } function htmlEscape(text) { @@ -12014,6 +12025,21 @@ function parseLogLine(line) { msg: String(parsed.msg ?? "") }; } +async function clearErrors() { + logWarnings = 0; + logErrors = 0; + log("clearErrors"); +} +async function initClearErrorsButton() { + const btnServerClear = document.getElementById("btn_console_log_server_clear"); + if (btnServerClear) { + btnServerClear.onclick = async (evt) => { + evt.preventDefault(); + evt.stopPropagation(); + clearErrors(); + }; + } +} async function logMonitor() { const addLogLine = (line) => { if (!logMonitorEl) logMonitorEl = document.getElementById("logMonitorData"); @@ -12024,14 +12050,13 @@ async function logMonitor() { const level = `${l.level}`; if (l.level === "WARNING") logWarnings++; if (l.level === "ERROR") logErrors++; - const module = `${l.module}`; + const module = `${l.module}`; const facilityText = l.facility.length > 20 ? `${l.facility.substring(0, 20)}...` : l.facility; - const facility = l.facility !== "sd" ? `${facilityText}` : ""; + const facility = l.facility !== "sd" ? `${facilityText}` : ""; row.innerHTML = `${dateToStr(l.created)}${level}${facility}${module}${htmlEscape(l.msg)}`; logMonitorEl.appendChild(row); } catch (err) { - error(`logMonitor: ${String(err)}`); - error(`logMonitor: ${line}`); + error("logMonitor", { error: String(err), line }); } }; const cleanupLog = (atBottom2) => { @@ -12046,7 +12071,13 @@ async function logMonitor() { const modenUIBtn = document.getElementById("btn_console"); if (elWarn) elWarn.innerText = String(logWarnings); if (elErr) elErr.innerText = String(logErrors); - if (modenUIBtn) modenUIBtn.setAttribute("error-count", logErrors > 0 ? String(logErrors) : ""); + if (modenUIBtn) { + modenUIBtn.setAttribute("error-count", logErrors > 0 ? String(logErrors) : ""); + modenUIBtn.style.backgroundColor = logErrors > 0 ? "var(--color-error)" : ""; + modenUIBtn.title = `Log +Errors ${logErrors} +Warnings ${logWarnings}`; + } }; const txtGallery = document.getElementById("txt2img_gallery"); if (txtGallery) txtGallery.style.height = window.opts.logmonitor_show ? "50vh" : "55vh"; @@ -12080,51 +12111,66 @@ async function logMonitor() { if (logMonitorEl && lines?.length > 0 && logMonitorEl.parentElement?.parentElement instanceof HTMLElement) { logMonitorEl.parentElement.parentElement.style.display = window.opts.logmonitor_show ? "block" : "none"; } - for (const line of lines) addLogLine(line); if (!logConnected) { logConnected = true; xhrPost(`${window.api}/log`, { debug: "connected" }); + logErrors = 0; } + for (const line of lines) addLogLine(line); } else { logConnected = false; logErrors++; - addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Failed to fetch log: ${res?.status} ${res?.statusText}" }`); + if (res) addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Failed to fetch log: ${res?.status} ${res?.statusText}" }`); + else addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Server unreachable" }`); } cleanupLog(atBottom); } catch { logConnected = false; logErrors++; - addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Failed to fetch log: server unreachable" }`); + addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Server unreachable" }`); cleanupLog(atBottom); } } async function initLogMonitor() { - const el2 = document.getElementsByTagName("footer")[0]; + let el2 = document.getElementById("logMonitorPlaceholder"); + const modernUi = Boolean(el2); + if (!el2) el2 = document.getElementsByTagName("footer")[0]; if (!el2) return; const t0 = performance.now(); el2.classList.add("log-monitor"); const uiDisabled = Array.isArray(window.opts.ui_disabled) ? window.opts.ui_disabled : []; if (uiDisabled.includes("logs")) return; - el2.innerHTML = ` - - - - - - - - - - - - - - -
TimeLevelModuleMessageWarnings 0Errors 0
- `; + if (modernUi) { + el2.style.overflow = "auto"; + el2.innerHTML = ` + + + +
+ `; + } else { + el2.innerHTML = ` + + + + + + + + + + + + + + +
TimeLevelModuleMessageWarnings 0Errors 0
+ `; + } el2.style.display = "none"; authFetch(`${window.api}/start?agent=${encodeURI(navigator.userAgent)}`); logMonitor(); + initClearErrorsButton(); const t1 = performance.now(); log("initLogMonitor", { show: window.opts.logmonitor_show, time: Math.round(t1 - t0) }); timer("initLogMonitor", t1 - t0); @@ -12183,7 +12229,7 @@ async function updateOpts(json_string) { else opts_tabs[meta.tab_name].saved_keys.add(opt); }); const t2 = performance.now(); - log("updateOpts", `settings=${Object.keys(new_opts).length} callbacks=${Math.round(t2 - t1)} apply=${Math.round(t1 - t0)}`); + log("updateOpts", { settings: Object.keys(new_opts).length, callbacks: Math.round(t2 - t1), apply: Math.round(t1 - t0) }); timer("updateOpts", t2 - t0); } function showAllSettings() { @@ -12926,7 +12972,6 @@ var minCleanupCount = 1e3; var minCleanupTime = 1e3 * 60 * 60; var folderStylesheet = new CSSStyleSheet(); var fileStylesheet = new CSSStyleSheet(); -var iconStopwatch = String.fromCodePoint(9201); var separatorStates = /* @__PURE__ */ new Map(); var el = { folders: void 0, @@ -12940,6 +12985,13 @@ var el = { var cleanupTimers = {}; var maintenanceTimers = {}; var fetchQueue = []; +var icons = { + Time: String.fromCodePoint(9201), + Folder: String.fromCodePoint(128448), + // or 128449; + Sort: String.fromCodePoint(8645), + Images: String.fromCodePoint(128461) +}; var SUPPORTED_EXTENSIONS = ["jpg", "jpeg", "png", "webp", "tiff", "jp2", "jxl", "gif", "mp4", "mkv", "avi", "mjpeg", "mpg", "avr"]; var gallerySorter = { nameA: { name: "Name Ascending", func: (a, b) => a.name.localeCompare(b.name) }, @@ -13099,9 +13151,9 @@ function updateGalleryStyles() { padding: 4px; font-size: 1.2em; letter-spacing: 0.5em; - width: 140px; margin-top: calc(140px - 32px); opacity: 75%; + border-radius: var(--sd-border-radius); } :host(.gallery-file-selected) .gallery-file { box-shadow: 0 0 0 2px var(--sd-button-selected-color); @@ -13151,6 +13203,10 @@ var SimpleProgressBar = class { if (total <= 0) return; this.hide(); this.#max = total; + if (this.#monitoredSet.size >= this.#max) { + this.stop(); + return; + } this.#interval = setInterval(() => this.update(this.#monitoredSet.size, this.#max), 100); } attachTo(element) { @@ -13174,7 +13230,6 @@ var SimpleProgressBar = class { } stop() { clearInterval(this.#interval); - this.#interval = void 0; if (this.stats.count) { debug("gallery: thumbnail stats", this.stats); this.stats = { ...this.defaultStats }; @@ -13461,7 +13516,7 @@ Size: ${this.size.toLocaleString()} bytes Modified: ${this.mtime.toLocaleString()}`; this.title = img.title; const shouldDisplayBasedOnSearch = this.title.toLowerCase().includes(el.search.value.toLowerCase()); - if (this.style.display !== "none") this.style.display = shouldDisplayBasedOnSearch ? "flex" : "none"; + if (this.style.display !== "none") this.style.display = shouldDisplayBasedOnSearch ? "" : "none"; this.shadow.appendChild(img); pb.stats.elapsed = (pb.stats.elapsed || 0) + Math.round(performance.now() - t0); } @@ -13478,7 +13533,7 @@ async function handleSeparator(separator) { const fileDir = f.name.match(/(.*)[/\\]/); const fileDirPath = fileDir ? fileDir[1] : ""; if (separator.title.length > 0 && fileDirPath === separator.title) { - f.style.display = nowHidden ? "none" : "unset"; + f.style.display = nowHidden ? "none" : ""; } } } @@ -13547,24 +13602,22 @@ async function addSeparators() { } var gallerySendImage = (_images) => [currentImage]; window.gallerySendImage = gallerySendImage; -function updateStatusWithSort(...messages) { +function updateStatusLine(...messages) { if (!el.status) return; messages.unshift(["Sort", sortMode.name]); const fragment = document.createDocumentFragment(); for (let i = 0; i < messages.length; i++) { const div = document.createElement("div"); if (Array.isArray(messages[i])) { - const [text1, text2] = messages[i]; - const tDiv1 = document.createElement("div"); - tDiv1.innerText = `${text1}:`; - const tDiv2 = document.createElement("div"); - tDiv2.innerText = text2; - tDiv2.title = text2; - div.append(tDiv1, tDiv2); + const [k, v] = messages[i]; + const tDiv = document.createElement("div"); + const ico = icons[k] || `${k}:`; + tDiv.innerText = `${ico} ${v}`; + div.append(tDiv); } else { - const tDiv1 = document.createElement("div"); - tDiv1.innerText = messages[i]; - div.append(tDiv1); + const tDiv = document.createElement("div"); + tDiv.innerText = messages[i]; + div.append(tDiv); } fragment.append(div); } @@ -13643,7 +13696,7 @@ async function gallerySearch() { const isOpen = separatorStates.get(dirPath); f.style.display = !dirPath || isOpen ? "unset" : "none"; }); - updateStatusWithSort("Filter", "Cleared", ["Images", allFiles.length.toLocaleString()]); + updateStatusLine("Filter", "Cleared", ["Images", allFiles.length.toLocaleString()]); return; } let totalFound = 0; @@ -13688,7 +13741,7 @@ async function gallerySearch() { f.style.display = fileMatches.has(f) ? "unset" : "none"; } const t1 = performance.now(); - updateStatusWithSort("Filter", ["Images", `${totalFound.toLocaleString()} / ${allFiles.length.toLocaleString()}`], `${iconStopwatch} ${Math.round(t1 - t0).toLocaleString()}ms`); + updateStatusLine("Filter", ["Images", `${totalFound.toLocaleString()} / ${allFiles.length.toLocaleString()}`], ["Time", `${Math.round(t1 - t0).toLocaleString()}ms`]); timer(`galleryFilter:${str}`, t1 - t0); refreshGallerySelection(); }, 250); @@ -13713,15 +13766,15 @@ async function gallerySort(key) { const folderGroups = /* @__PURE__ */ new Map(); for (const file of subfolderFiles) { const dir = getDirPath(file); - if (!folderGroups.has(dir)) { - folderGroups.set(dir, []); - } + if (!folderGroups.has(dir)) folderGroups.set(dir, []); folderGroups.get(dir).push(file); } sortMode = gallerySorter[currentSort]; rootFiles.sort(sortMode.func); rootFiles.forEach((node) => fragment.appendChild(node)); - const sortedFolderNames = Array.from(folderGroups.keys()).sort((a, b) => a.localeCompare(b)); + const folderNames = Array.from(folderGroups.keys()); + const sortedFolderNames = currentSort.endsWith("A") ? folderNames.sort((a, b) => a.localeCompare(b)) : folderNames.sort((a, b) => b.localeCompare(a)); + console.log("HERE", sortedFolderNames); for (const folderName of sortedFolderNames) { const files = folderGroups.get(folderName); files.sort(sortMode.func); @@ -13745,7 +13798,7 @@ async function gallerySort(key) { } const t1 = performance.now(); log(`gallerySort: sort=${sortMode.name} len=${arr.length} time=${Math.floor(t1 - t0)}`); - updateStatusWithSort(["Images", arr.length.toLocaleString()], `${iconStopwatch} ${Math.round(t1 - t0).toLocaleString()}ms`); + updateStatusLine(["Images", arr.length.toLocaleString()], ["Time", `${Math.round(t1 - t0).toLocaleString()}ms`]); timer(`gallerySort:${sortMode.name}`, t1 - t0); refreshGallerySelection(); } @@ -13815,7 +13868,7 @@ async function thumbCacheCleanup(folder, imgCount, controller, force = false) { log("galleryMaintenance", { folder, kept: keptGalleryHashes.size, deleted: delcount, time: Math.round(t1 - t0) }); timer(`thumbnailDBCleanup:${folder}`, t1 - t0); currentGalleryFolder = null; - updateStatusWithSort("Thumbnail cache cleared"); + updateStatusLine("Thumbnail cache cleared"); }).catch((reason) => { SimpleFunctionQueue.abortLogger("thumbCacheCleanup", reason); }).finally(async () => { @@ -13847,11 +13900,11 @@ window.clearCache = clearCache; async function fetchFilesHT(evt, controller) { const t0 = performance.now(); const fragment = document.createDocumentFragment(); - updateStatusWithSort(["Folder", evt.target.name], "in-progress"); + updateStatusLine(["Folder", evt.target.name], "in-progress"); let numFiles = 0; const res = await authFetch(`${window.api}/browser/files?folder=${encodeURI(evt.target.name)}`); if (!res || res.status !== 200) { - updateStatusWithSort(["Folder", evt.target.name], ["Failed", res?.statusText || "No response"]); + updateStatusLine(["Folder", evt.target.name], ["Failed", res?.statusText || "No response"]); return; } const jsonData = await res.json(); @@ -13870,7 +13923,7 @@ async function fetchFilesHT(evt, controller) { const t1 = performance.now(); log(`gallery: folder=${evt.target.name} num=${numFiles} method=http time=${Math.floor(t1 - t0)}ms`); timer(`galleryFetch:${evt.target.name}`, t1 - t0); - updateStatusWithSort(["Folder", evt.target.name], ["Images", numFiles.toLocaleString()], `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`); + updateStatusLine(["Folder", evt.target.name], ["Images", numFiles.toLocaleString()], ["Time", `${Math.floor(t1 - t0).toLocaleString()}ms`]); pb.start(numFiles); addSeparators(); refreshGallerySelection(); @@ -13896,7 +13949,7 @@ async function fetchFilesWS(evt) { await fetchFilesHT(evt, controller); return; } - updateStatusWithSort(["Folder", evt.target.name]); + updateStatusLine(["Folder", evt.target.name]); const t0 = performance.now(); let numFiles = 0; let t1 = performance.now(); @@ -13914,7 +13967,7 @@ async function fetchFilesWS(evt) { numFiles++; fragment.appendChild(file); if (numFiles % fragmentSize === 0) { - updateStatusWithSort(["Folder", evt.target.name], ["Images", numFiles.toLocaleString()], "in-progress", `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`); + updateStatusLine(["Folder", evt.target.name], ["Images", numFiles.toLocaleString()], ["Status", "in-progress"], ["Time", `${Math.floor(t1 - t0).toLocaleString()}ms`]); el.files.appendChild(fragment); fragment = document.createDocumentFragment(); } @@ -13925,7 +13978,7 @@ async function fetchFilesWS(evt) { if (controller.signal.aborted) return; el.files.appendChild(fragment); log(`gallery: folder=${evt.target.name} num=${numFiles} method=ws time=${Math.floor(t1 - t0)}ms`); - updateStatusWithSort(["Folder", evt.target.name], ["Images", numFiles.toLocaleString()], `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`); + updateStatusLine(["Folder", evt.target.name], ["Images", numFiles.toLocaleString()], ["Time", `${Math.floor(t1 - t0).toLocaleString()}ms`]); pb.start(numFiles); addSeparators(); refreshGallerySelection(); @@ -14011,7 +14064,7 @@ async function initGalleryAutoRefresh() { galleryVisObserver.observe(galleryTab, { attributeFilter: ["class", "style"], attributeOldValue: true }); } async function overlayDelete(evt) { - const res = await authFetch(`${window.api}/delete-image?file=${encodeURIComponent(currentImage)}`); + const res = await authFetch(`${window.api}/delete-image?file=${encodeURIComponent(currentImage)}`, { method: "DELETE" }); evt.stopPropagation(); if (!res || res.status !== 200) { error("galleryDelete", { file: currentImage, status: res?.status, statusText: res?.statusText }); @@ -15427,7 +15480,7 @@ async function getLocaleData(desiredLocale = null) { localeData.locale = desiredLocale || "en"; localeData.prev = localeData.locale; } - log("getLocale", desiredLocale, localeData.locale); + log("getLocale", { lang: desiredLocale, locale: localeData.locale }); let json = {}; try { let res = await fetch(`${window.subpath}/file=ui/locale/locale_${localeData.locale}.json`); @@ -15873,7 +15926,10 @@ async function createSplash() { monitorLog(); await authFetch(`${window.api}/motd`).then((res) => res.text()).then((text) => { const clean = text.replace(/["]+/g, ""); - log("getMOTD", clean); + const boldMatch = clean.match(/(.*?)<\/b>/); + const boldText = boldMatch ? boldMatch[1] : clean; + if (boldMatch) log("getMOTD", { version: boldText }); + else log("getMOTD", { text: clean }); const motdEl = document.getElementById("motd"); if (motdEl) motdEl.innerHTML = clean; }).catch((err) => error(`getMOTD: ${err}`)); @@ -15922,6 +15978,14 @@ async function postStartup() { disconnectHintsObserver(); logTimers(); } +async function updateSubpath() { + log("mountURL", window.opts.subpath); + if (window.opts.subpath?.length > 0) { + window.subpath = window.opts.subpath; + window.api = `${window.subpath}/sdapi/v1`; + } + log("API", { url: window.api }); +} async function initStartup() { const t0 = performance.now(); log("initGradio", Math.round(t0 - appStartTime)); @@ -15942,14 +16006,10 @@ async function initStartup() { startupPromises.push(Promise.resolve(setupControlUI())); await reconnectUI(); await waitForOpts(); - log("mountURL", window.opts.subpath); - if (window.opts.subpath?.length > 0) { - window.subpath = window.opts.subpath; - window.api = `${window.subpath}/sdapi/v1`; - } - startupPromises.push(initLogMonitor()); + await updateSubpath(); executeCallbacks(uiReadyCallbacks); if (window.waitForUiReady) await window.waitForUiReady(); + startupPromises.push(Promise.resolve(initLogMonitor())); startupPromises.push(Promise.resolve(initGallery())); startupPromises.push(Promise.resolve(setRefreshInterval())); startupPromises.push(Promise.resolve(setupExtraNetworks())); @@ -19127,12 +19187,12 @@ async function updateGPU() { } const gpuTbody = gpuTable.querySelector("tbody"); if (!gpuTbody) return; - for (const gpu of data) { - let rows = `GPU${gpu.name}`; - for (const item of Object.entries(gpu.data)) rows += `${item[0]}${item[1]}`; - gpuTbody.innerHTML = rows; - if (gpu.chart && gpu.chart.length === 2) updateGPUChart(gpu.chart[0], gpu.chart[1]); - } + let gpu = { data: {} }; + if (Array.isArray(data) && data.length >= 1) gpu = data[0]; + let rows = `GPU${gpu.name || "unknown"}`; + for (const item of Object.entries(gpu.data)) rows += `${item[0]}${item[1]}`; + gpuTbody.innerHTML = rows; + if (gpu.chart && gpu.chart.length === 2) updateGPUChart(gpu.chart[0], gpu.chart[1]); gpuEl.style.display = "block"; } catch (e) { error("updateGPU", e); @@ -19146,7 +19206,7 @@ async function startGPU() { gpuEl.style.display = "block"; if (gpuInterval) clearInterval(gpuInterval); const interval = window.opts?.gpu_monitor || 3e3; - log("startGPU", interval); + log("startGPUmonitor", interval); gpuInterval = setInterval(updateGPU, interval); updateGPU(); } diff --git a/ui/dist/sdnext.mjs.map b/ui/dist/sdnext.mjs.map index d1b9c2208..7eba30e22 100644 --- a/ui/dist/sdnext.mjs.map +++ b/ui/dist/sdnext.mjs.map @@ -1,7 +1,7 @@ { "version": 3, "sources": ["../../node_modules/.pnpm/jquery@4.0.0/node_modules/jquery/dist/jquery.js", "../js/iframeResizer.js", "../../node_modules/.pnpm/exifr@7.1.3/node_modules/exifr/dist/full.umd.js", "../../node_modules/.pnpm/wheel@1.0.0/node_modules/wheel/index.js", "../../node_modules/.pnpm/bezier-easing@2.1.0/node_modules/bezier-easing/src/index.js", "../../node_modules/.pnpm/amator@1.1.0/node_modules/amator/index.js", "../../node_modules/.pnpm/ngraph.events@1.4.0/node_modules/ngraph.events/index.js", "../../node_modules/.pnpm/panzoom@9.4.4/node_modules/panzoom/lib/kinetic.js", "../../node_modules/.pnpm/panzoom@9.4.4/node_modules/panzoom/lib/makeTextSelectionInterceptor.js", "../../node_modules/.pnpm/panzoom@9.4.4/node_modules/panzoom/lib/transform.js", "../../node_modules/.pnpm/panzoom@9.4.4/node_modules/panzoom/lib/makeSvgController.js", "../../node_modules/.pnpm/panzoom@9.4.4/node_modules/panzoom/lib/makeDomController.js", "../../node_modules/.pnpm/panzoom@9.4.4/node_modules/panzoom/index.js", "../../node_modules/.pnpm/jquery@4.0.0/node_modules/jquery/dist-module/wrappers/jquery.node-module-wrapper.js", "../vendor.ts", "../logger.ts", "../authWrap.ts", "../timers.ts", "../script.ts", "../changelog.ts", "../control.ts", "../extraNetworks.ts", "../generationParams.ts", "../imageParams.ts", "../notification.ts", "../progressBar.ts", "../ui.ts", "../inputAccordion.ts", "../indexdb.ts", "../logMonitor.ts", "../settings.ts", "../monitor.ts", "../promptChecker.ts", "../js/sha256.ts", "../gallery.ts", "../imageViewer.ts", "../autocomplete_xn.ts", "../autocomplete.ts", "../setHints.ts", "../contextMenus.ts", "../uiConfig.ts", "../loader.ts", "../legacy.ts", "../startup.ts", "../extensions.ts", "../dragDrop.ts", "../civitai.ts", "../guidance.ts", "../timesheet.ts", "../history.ts", "../aspectRatioOverlay.ts", "../resolutionLock.ts", "../editAttention.ts", "../../node_modules/.pnpm/jquery-sparkline@2.4.0/node_modules/jquery-sparkline/jquery.sparkline.js", "../gpu.ts"], - "sourcesContent": ["/*!\n * jQuery JavaScript Library v4.0.0\n * https://jquery.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.com/license/\n *\n * Date: 2026-01-18T00:20Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\tmodule.exports = factory( global, true );\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n\"use strict\";\n\nif ( !window.document ) {\n\tthrow new Error( \"jQuery requires a window with a document\" );\n}\n\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\n// Support: IE 11+\n// IE doesn't have Array#flat; provide a fallback.\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\n// [[Class]] -> type pairs\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\n// All support tests are defined in their respective modules.\nvar support = {};\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\treturn typeof obj === \"object\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof obj;\n}\n\nfunction isWindow( obj ) {\n\treturn obj != null && obj === obj.window;\n}\n\nfunction isArrayLike( obj ) {\n\n\tvar length = !!obj && obj.length,\n\t\ttype = toType( obj );\n\n\tif ( typeof obj === \"function\" || isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\n\nvar document$1 = window.document;\n\nvar preservedScriptAttributes = {\n\ttype: true,\n\tsrc: true,\n\tnonce: true,\n\tnoModule: true\n};\n\nfunction DOMEval( code, node, doc ) {\n\tdoc = doc || document$1;\n\n\tvar i,\n\t\tscript = doc.createElement( \"script\" );\n\n\tscript.text = code;\n\tfor ( i in preservedScriptAttributes ) {\n\t\tif ( node && node[ i ] ) {\n\t\t\tscript[ i ] = node[ i ];\n\t\t}\n\t}\n\n\tif ( doc.head.appendChild( script ).parentNode ) {\n\t\tscript.parentNode.removeChild( script );\n\t}\n}\n\nvar version = \"4.0.0\",\n\n\trhtmlSuffix = /HTML$/i,\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teven: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn ( i + 1 ) % 2;\n\t\t} ) );\n\t},\n\n\todd: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn i % 2;\n\t\t} ) );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t}\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && typeof target !== \"function\" ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent Object.prototype pollution\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( name === \"__proto__\" || target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\t\t\t\t\tsrc = target[ name ];\n\n\t\t\t\t\t// Ensure proper type for the source value\n\t\t\t\t\tif ( copyIsArray && !Array.isArray( src ) ) {\n\t\t\t\t\t\tclone = [];\n\t\t\t\t\t} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\n\t\t\t\t\t\tclone = {};\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src;\n\t\t\t\t\t}\n\t\t\t\t\tcopyIsArray = false;\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\t// Evaluates a script in a provided context; falls back to the global one\n\t// if not specified.\n\tglobalEval: function( code, options, doc ) {\n\t\tDOMEval( code, { nonce: options && options.nonce }, doc );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\n\t// Retrieve the text value of an array of DOM nodes\n\ttext: function( elem ) {\n\t\tvar node,\n\t\t\tret = \"\",\n\t\t\ti = 0,\n\t\t\tnodeType = elem.nodeType;\n\n\t\tif ( !nodeType ) {\n\n\t\t\t// If no nodeType, this is expected to be an array\n\t\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t\t// Do not traverse comment nodes\n\t\t\t\tret += jQuery.text( node );\n\t\t\t}\n\t\t}\n\t\tif ( nodeType === 1 || nodeType === 11 ) {\n\t\t\treturn elem.textContent;\n\t\t}\n\t\tif ( nodeType === 9 ) {\n\t\t\treturn elem.documentElement.textContent;\n\t\t}\n\t\tif ( nodeType === 3 || nodeType === 4 ) {\n\t\t\treturn elem.nodeValue;\n\t\t}\n\n\t\t// Do not include comment or processing instruction nodes\n\n\t\treturn ret;\n\t},\n\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\tisXMLDoc: function( elem ) {\n\t\tvar namespace = elem && elem.namespaceURI,\n\t\t\tdocElem = elem && ( elem.ownerDocument || elem ).documentElement;\n\n\t\t// Assume HTML when documentElement doesn't yet exist, such as inside\n\t\t// document fragments.\n\t\treturn !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n\t},\n\n\t// Note: an element does not contain itself\n\tcontains: function( a, b ) {\n\t\tvar bup = b && b.parentNode;\n\n\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\n\t\t\t// Support: IE 9 - 11+\n\t\t\t// IE doesn't have `contains` on SVG.\n\t\t\ta.contains ?\n\t\t\t\ta.contains( bup ) :\n\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t) );\n\t},\n\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn flat( ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\n\tfunction( _i, name ) {\n\t\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n\t} );\n\nfunction nodeName( elem, name ) {\n\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n}\n\nvar pop = arr.pop;\n\n// https://www.w3.org/TR/css3-selectors/#whitespace\nvar whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\";\n\nvar isIE = document$1.documentMode;\n\nvar rbuggyQSA = isIE && new RegExp(\n\n\t// Support: IE 9 - 11+\n\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\":enabled|:disabled|\" +\n\n\t// Support: IE 11+\n\t// IE 11 doesn't find elements on a `[name='']` query in some cases.\n\t// Adding a temporary attribute to the document before the selection works\n\t// around the issue.\n\t\"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\twhitespace + \"*(?:''|\\\"\\\")\"\n\n);\n\nvar rtrimCSS = new RegExp(\n\t\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\",\n\t\"g\"\n);\n\n// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\nvar identifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\";\n\nvar rleadingCombinator = new RegExp( \"^\" + whitespace + \"*([>+~]|\" +\n\twhitespace + \")\" + whitespace + \"*\" );\n\nvar rdescend = new RegExp( whitespace + \"|>\" );\n\nvar rsibling = /[+~]/;\n\nvar documentElement$1 = document$1.documentElement;\n\n// Support: IE 9 - 11+\n// IE requires a prefix.\nvar matches = documentElement$1.matches || documentElement$1.msMatchesSelector;\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\n\t\t// Use (key + \" \") to avoid collision with native prototype properties\n\t\t// (see https://github.com/jquery/sizzle/issues/157)\n\t\tif ( keys.push( key + \" \" ) > jQuery.expr.cacheLength ) {\n\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn ( cache[ key + \" \" ] = value );\n\t}\n\treturn cache;\n}\n\n/**\n * Checks a node for validity as a jQuery selector context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors\nvar attributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t// Operator (capture 2)\n\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\twhitespace + \"*\\\\]\";\n\nvar pseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n\t// 2. simple (capture 6)\n\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n\t// 3. anything else (capture 2)\n\t\".*\" +\n\t\")\\\\)|)\";\n\nvar filterMatchExpr = {\n\tID: new RegExp( \"^#(\" + identifier + \")\" ),\n\tCLASS: new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\tTAG: new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\tATTR: new RegExp( \"^\" + attributes ),\n\tPSEUDO: new RegExp( \"^\" + pseudos ),\n\tCHILD: new RegExp(\n\t\t\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" )\n};\n\nvar rpseudo = new RegExp( pseudos );\n\n// CSS escapes\n// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\nvar runescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\tif ( nonHex ) {\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\treturn nonHex;\n\t\t}\n\n\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t// Support: IE <=11+\n\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t// surrogate pair\n\t\treturn high < 0 ?\n\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t};\n\nfunction unescapeSelector( sel ) {\n\treturn sel.replace( runescape, funescape );\n}\n\nfunction selectorError( msg ) {\n\tjQuery.error( \"Syntax error, unrecognized expression: \" + msg );\n}\n\nvar rcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" );\n\nvar tokenCache = createCache();\n\nfunction tokenize( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = jQuery.expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || ( match = rcomma.exec( soFar ) ) ) {\n\t\t\tif ( match ) {\n\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[ 0 ].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( ( tokens = [] ) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( ( match = rleadingCombinator.exec( soFar ) ) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push( {\n\t\t\t\tvalue: matched,\n\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[ 0 ].replace( rtrimCSS, \" \" )\n\t\t\t} );\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in filterMatchExpr ) {\n\t\t\tif ( ( match = jQuery.expr.match[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\n\t\t\t\t( match = preFilters[ type ]( match ) ) ) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push( {\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t} );\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\tif ( parseOnly ) {\n\t\treturn soFar.length;\n\t}\n\n\treturn soFar ?\n\t\tselectorError( selector ) :\n\n\t\t// Cache the tokens\n\t\ttokenCache( selector, groups ).slice( 0 );\n}\n\nvar preFilter = {\n\tATTR: function( match ) {\n\t\tmatch[ 1 ] = unescapeSelector( match[ 1 ] );\n\n\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\tmatch[ 3 ] = unescapeSelector( match[ 3 ] || match[ 4 ] || match[ 5 ] || \"\" );\n\n\t\tif ( match[ 2 ] === \"~=\" ) {\n\t\t\tmatch[ 3 ] = \" \" + match[ 3 ] + \" \";\n\t\t}\n\n\t\treturn match.slice( 0, 4 );\n\t},\n\n\tCHILD: function( match ) {\n\n\t\t/* matches from filterMatchExpr[\"CHILD\"]\n\t\t\t1 type (only|nth|...)\n\t\t\t2 what (child|of-type)\n\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t5 sign of xn-component\n\t\t\t6 x of xn-component\n\t\t\t7 sign of y-component\n\t\t\t8 y of y-component\n\t\t*/\n\t\tmatch[ 1 ] = match[ 1 ].toLowerCase();\n\n\t\tif ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\n\n\t\t\t// nth-* requires argument\n\t\t\tif ( !match[ 3 ] ) {\n\t\t\t\tselectorError( match[ 0 ] );\n\t\t\t}\n\n\t\t\t// numeric x and y parameters for jQuery.expr.filter.CHILD\n\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\tmatch[ 4 ] = +( match[ 4 ] ?\n\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" )\n\t\t\t);\n\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t// other types prohibit arguments\n\t\t} else if ( match[ 3 ] ) {\n\t\t\tselectorError( match[ 0 ] );\n\t\t}\n\n\t\treturn match;\n\t},\n\n\tPSEUDO: function( match ) {\n\t\tvar excess,\n\t\t\tunquoted = !match[ 6 ] && match[ 2 ];\n\n\t\tif ( filterMatchExpr.CHILD.test( match[ 0 ] ) ) {\n\t\t\treturn null;\n\t\t}\n\n\t\t// Accept quoted arguments as-is\n\t\tif ( match[ 3 ] ) {\n\t\t\tmatch[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\n\n\t\t// Strip excess characters from unquoted arguments\n\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\n\t\t\t// Get excess from tokenize (recursively)\n\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\n\t\t\t// advance to the next closing parenthesis\n\t\t\t( excess = unquoted.indexOf( \")\", unquoted.length - excess ) -\n\t\t\t\tunquoted.length ) ) {\n\n\t\t\t// excess is a negative index\n\t\t\tmatch[ 0 ] = match[ 0 ].slice( 0, excess );\n\t\t\tmatch[ 2 ] = unquoted.slice( 0, excess );\n\t\t}\n\n\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\treturn match.slice( 0, 3 );\n\t}\n};\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[ i ].value;\n\t}\n\treturn selector;\n}\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nfunction access( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( toType( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( typeof value !== \"function\" ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, _key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\t\tvalue :\n\t\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n}\n\n// Only count HTML whitespace\n// Other whitespace should count in values\n// https://infra.spec.whatwg.org/#ascii-whitespace\nvar rnothtmlwhite = /[^\\x20\\t\\r\\n\\f]+/g;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ||\n\n\t\t\t\t// For compat with previous handling of boolean attributes,\n\t\t\t\t// remove when `false` passed. For ARIA attributes -\n\t\t\t\t// many of which recognize a `\"false\"` value - continue to\n\t\t\t\t// set the `\"false\"` value as jQuery <4 did.\n\t\t\t\t( value === false && name.toLowerCase().indexOf( \"aria-\" ) !== 0 ) ) {\n\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = elem.getAttribute( name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Support: IE <=11+\n// An input loses its value after becoming a radio\nif ( isIE ) {\n\tjQuery.attrHooks.type = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( value === \"radio\" && nodeName( elem, \"input\" ) ) {\n\t\t\t\tvar val = elem.value;\n\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\tif ( val ) {\n\t\t\t\t\telem.value = val;\n\t\t\t\t}\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\t};\n}\n\n// CSS string/identifier serialization\n// https://drafts.csswg.org/cssom/#common-serializing-idioms\nvar rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g;\n\nfunction fcssescape( ch, asCodePoint ) {\n\tif ( asCodePoint ) {\n\n\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\tif ( ch === \"\\0\" ) {\n\t\t\treturn \"\\uFFFD\";\n\t\t}\n\n\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\treturn ch.slice( 0, -1 ) + \"\\\\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t}\n\n\t// Other potentially-special ASCII characters get backslash-escaped\n\treturn \"\\\\\" + ch;\n}\n\njQuery.escapeSelector = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\nvar sort = arr.sort;\n\nvar splice = arr.splice;\n\nvar hasDuplicate;\n\n// Document order sorting\nfunction sortOrder( a, b ) {\n\n\t// Flag for duplicate removal\n\tif ( a === b ) {\n\t\thasDuplicate = true;\n\t\treturn 0;\n\t}\n\n\t// Sort on method existence if only one input has compareDocumentPosition\n\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\tif ( compare ) {\n\t\treturn compare;\n\t}\n\n\t// Calculate position if both inputs belong to the same document\n\t// Support: IE 11+\n\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tcompare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\n\t\ta.compareDocumentPosition( b ) :\n\n\t\t// Otherwise we know they are disconnected\n\t\t1;\n\n\t// Disconnected nodes\n\tif ( compare & 1 ) {\n\n\t\t// Choose the first element that is related to the document\n\t\t// Support: IE 11+\n\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tif ( a == document$1 || a.ownerDocument == document$1 &&\n\t\t\tjQuery.contains( document$1, a ) ) {\n\t\t\treturn -1;\n\t\t}\n\n\t\t// Support: IE 11+\n\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tif ( b == document$1 || b.ownerDocument == document$1 &&\n\t\t\tjQuery.contains( document$1, b ) ) {\n\t\t\treturn 1;\n\t\t}\n\n\t\t// Maintain original order\n\t\treturn 0;\n\t}\n\n\treturn compare & 4 ? -1 : 1;\n}\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\njQuery.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\thasDuplicate = false;\n\n\tsort.call( results, sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tsplice.call( results, duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\treturn results;\n};\n\njQuery.fn.uniqueSort = function() {\n\treturn this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );\n};\n\nvar i,\n\toutermostContext,\n\n\t// Local document vars\n\tdocument,\n\tdocumentElement,\n\tdocumentIsHTML,\n\n\t// Instance-specific data\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\tcompilerCache = createCache(),\n\tnonnativeSelectorCache = createCache(),\n\n\t// Regular expressions\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = jQuery.extend( {\n\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\tneedsContext: new RegExp( \"^\" + whitespace +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t}, filterMatchExpr ),\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr$1 = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\t// Used for iframes; see `setDocument`.\n\t// Support: IE 9 - 11+\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE.\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && nodeName( elem, \"fieldset\" );\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\nfunction find( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\t\tsetDocument( context );\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && ( match = rquickExpr$1.exec( selector ) ) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( ( m = match[ 1 ] ) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( ( elem = context.getElementById( m ) ) ) {\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn results;\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif ( newContext && ( elem = newContext.getElementById( m ) ) &&\n\t\t\t\t\t\t\tjQuery.contains( context, elem ) ) {\n\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[ 2 ] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( !nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) &&\n\t\t\t\t\t\ttestContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\n\t\t\t\t\t// Outside of IE, if we're not changing the context we can\n\t\t\t\t\t// use :scope instead of an ID.\n\t\t\t\t\t// Support: IE 11+\n\t\t\t\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( newContext != context || isIE ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = jQuery.escapeSelector( nid );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = jQuery.expando ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === jQuery.expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrimCSS, \"$1\" ), context, results, seed );\n}\n\n/**\n * Mark a function for special use by jQuery selector module\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ jQuery.expando ] = true;\n\treturn fn;\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn nodeName( elem, \"input\" ) && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn ( nodeName( elem, \"input\" ) || nodeName( elem, \"button\" ) ) &&\n\t\t\telem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for :enabled/:disabled\n * @param {Boolean} disabled true for :disabled; false for :enabled\n */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t// https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t// https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t// https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11+\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\t\tinDisabledFieldset( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction( function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction( function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ ( j = matchIndexes[ i ] ) ] ) {\n\t\t\t\t\tseed[ j ] = !( matches[ j ] = seed[ j ] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t} );\n}\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [node] An element or document object to use to set the document\n */\nfunction setDocument( node ) {\n\tvar subWindow,\n\t\tdoc = node ? node.ownerDocument || node : document$1;\n\n\t// Return early if doc is invalid or already selected\n\t// Support: IE 11+\n\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( doc == document || doc.nodeType !== 9 ) {\n\t\treturn;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocumentElement = document.documentElement;\n\tdocumentIsHTML = !jQuery.isXMLDoc( document );\n\n\t// Support: IE 9 - 11+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (see trac-13936)\n\t// Support: IE 11+\n\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( isIE && document$1 != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\t\tsubWindow.addEventListener( \"unload\", unloadHandler );\n\t}\n}\n\nfind.matches = function( expr, elements ) {\n\treturn find( expr, null, null, elements );\n};\n\nfind.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\treturn matches.call( elem, expr );\n\t\t} catch ( e ) {\n\t\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn find( expr, document, null, [ elem ] ).length > 0;\n};\n\njQuery.expr = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tfind: {\n\t\tID: function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t},\n\n\t\tTAG: function( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t},\n\n\t\tCLASS: function( className, context ) {\n\t\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\t\treturn context.getElementsByClassName( className );\n\t\t\t}\n\t\t}\n\t},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: preFilter,\n\n\tfilter: {\n\t\tID: function( id ) {\n\t\t\tvar attrId = unescapeSelector( id );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t},\n\n\t\tTAG: function( nodeNameSelector ) {\n\t\t\tvar expectedNodeName = unescapeSelector( nodeNameSelector ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\n\t\t\t\tfunction() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn nodeName( elem, expectedNodeName );\n\t\t\t\t};\n\t\t},\n\n\t\tCLASS: function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace + \")\" + className +\n\t\t\t\t\t\"(\" + whitespace + \"|$)\" ) ) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\tATTR: function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = jQuery.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\tif ( operator === \"=\" ) {\n\t\t\t\t\treturn result === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"!=\" ) {\n\t\t\t\t\treturn result !== check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"^=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) === 0;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"*=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"$=\" ) {\n\t\t\t\t\treturn check && result.slice( -check.length ) === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"~=\" ) {\n\t\t\t\t\treturn ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" )\n\t\t\t\t\t\t.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"|=\" ) {\n\t\t\t\t\treturn result === check || result.slice( 0, check.length + 1 ) === check + \"-\";\n\t\t\t\t}\n\n\t\t\t\treturn false;\n\t\t\t};\n\t\t},\n\n\t\tCHILD: function( type, what, _argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tvar cache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( ( node = node[ dir ] ) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\t\t\t\t\t\t\touterCache = parent[ jQuery.expando ] ||\n\t\t\t\t\t\t\t\t( parent[ jQuery.expando ] = {} );\n\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\touterCache = elem[ jQuery.expando ] ||\n\t\t\t\t\t\t\t\t\t( elem[ jQuery.expando ] = {} );\n\t\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ jQuery.expando ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( node[ jQuery.expando ] = {} );\n\t\t\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\tPSEUDO: function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// https://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar fn = jQuery.expr.pseudos[ pseudo ] ||\n\t\t\t\tjQuery.expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\tselectorError( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as jQuery does\n\t\t\tif ( fn[ jQuery.expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\n\t\t// Potentially complex pseudos\n\t\tnot: markFunction( function( selector ) {\n\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrimCSS, \"$1\" ) );\n\n\t\t\treturn matcher[ jQuery.expando ] ?\n\t\t\t\tmarkFunction( function( seed, matches, _context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\t\t\t\t\tseed[ i ] = !( matches[ i ] = elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} ) :\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tinput[ 0 ] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\n\t\t\t\t\t// Don't keep the element\n\t\t\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\t\t\tinput[ 0 ] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t} ),\n\n\t\thas: markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn find( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\tcontains: markFunction( function( text ) {\n\t\t\ttext = unescapeSelector( text );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t} ),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// https://www.w3.org/TR/selectors/#lang-pseudo\n\t\tlang: markFunction( function( lang ) {\n\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test( lang || \"\" ) ) {\n\t\t\t\tselectorError( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = unescapeSelector( lang ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( ( elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t} ),\n\n\t\t// Miscellaneous\n\t\ttarget: function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\troot: function( elem ) {\n\t\t\treturn elem === documentElement;\n\t\t},\n\n\t\tfocus: function( elem ) {\n\t\t\treturn elem === document.activeElement &&\n\t\t\t\tdocument.hasFocus() &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\tenabled: createDisabledPseudo( false ),\n\t\tdisabled: createDisabledPseudo( true ),\n\n\t\tchecked: function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\treturn ( nodeName( elem, \"input\" ) && !!elem.checked ) ||\n\t\t\t\t( nodeName( elem, \"option\" ) && !!elem.selected );\n\t\t},\n\n\t\tselected: function( elem ) {\n\n\t\t\t// Support: IE <=11+\n\t\t\t// Accessing the selectedIndex property\n\t\t\t// forces the browser to treat the default option as\n\t\t\t// selected when in an optgroup.\n\t\t\tif ( isIE && elem.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\tempty: function( elem ) {\n\n\t\t\t// https://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t// but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\tparent: function( elem ) {\n\t\t\treturn !jQuery.expr.pseudos.empty( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\theader: function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\tinput: function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\tbutton: function( elem ) {\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"button\" ||\n\t\t\t\tnodeName( elem, \"button\" );\n\t\t},\n\n\t\ttext: function( elem ) {\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"text\";\n\t\t},\n\n\t\t// Position-in-collection\n\t\tfirst: createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\tlast: createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\teq: createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\teven: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\todd: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tlt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i;\n\n\t\t\tif ( argument < 0 ) {\n\t\t\t\ti = argument + length;\n\t\t\t} else if ( argument > length ) {\n\t\t\t\ti = length;\n\t\t\t} else {\n\t\t\t\ti = argument;\n\t\t\t}\n\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tgt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} )\n\t}\n};\n\njQuery.expr.pseudos.nth = jQuery.expr.pseudos.eq;\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tjQuery.expr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tjQuery.expr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = jQuery.expr.pseudos;\njQuery.expr.setFilters = new setFilters();\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ jQuery.expando ] || ( elem[ jQuery.expando ] = {} );\n\n\t\t\t\t\t\tif ( skip && nodeName( elem, skip ) ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = outerCache[ key ] ) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn ( newCache[ 2 ] = oldCache[ 2 ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\touterCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[ i ]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[ 0 ];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tfind( selector, contexts[ i ], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ jQuery.expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ jQuery.expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction( function( seed, results, context, xml ) {\n\t\tvar temp, i, elem, matcherOut,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed ||\n\t\t\t\tmultipleContexts( selector || \"*\",\n\t\t\t\t\tcontext.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems;\n\n\t\tif ( matcher ) {\n\n\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter\n\t\t\t// or preexisting results,\n\t\t\tmatcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t[] :\n\n\t\t\t\t// ...otherwise use results directly\n\t\t\t\tresults;\n\n\t\t\t// Find primary matches\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t} else {\n\t\t\tmatcherOut = matcherIn;\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( ( elem = temp[ i ] ) ) {\n\t\t\t\t\tmatcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) ) {\n\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( ( matcherIn[ i ] = elem ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, ( matcherOut = [] ), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) &&\n\t\t\t\t\t\t( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {\n\n\t\t\t\t\t\tseed[ temp ] = !( results[ temp ] = elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t} );\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = jQuery.expr.relative[ tokens[ 0 ].type ],\n\t\timplicitRelative = leadingRelative || jQuery.expr.relative[ \" \" ],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf.call( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\n\t\t\t// Support: IE 11+\n\t\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tvar ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (\n\t\t\t\t( checkContext = context ).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\n\t\t\t// Avoid hanging onto element\n\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( matcher = jQuery.expr.relative[ tokens[ i ].type ] ) ) {\n\t\t\tmatchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\n\t\t} else {\n\t\t\tmatcher = jQuery.expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ jQuery.expando ] ) {\n\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( jQuery.expr.relative[ tokens[ j ].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 )\n\t\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrimCSS, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && jQuery.expr.find.TAG( \"*\", outermost ),\n\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 );\n\n\t\t\tif ( outermost ) {\n\n\t\t\t\t// Support: IE 11+\n\t\t\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\toutermostContext = context == document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\tfor ( ; ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\n\t\t\t\t\t// Support: IE 11+\n\t\t\t\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( !context && elem.ownerDocument != document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( ( matcher = elementMatchers[ j++ ] ) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml ) ) {\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( ( elem = !matcher && elem ) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( ( matcher = setMatchers[ j++ ] ) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !( unmatched[ i ] || setMatched[ i ] ) ) {\n\t\t\t\t\t\t\t\tsetMatched[ i ] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tjQuery.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\nfunction compile( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[ i ] );\n\t\t\tif ( cached[ jQuery.expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n}\n\n/**\n * A low-level selection function that works with jQuery's compiled\n * selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n * selector function built with jQuery selector compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nfunction select( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( ( selector = compiled.selector || selector ) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[ 0 ] = match[ 0 ].slice( 0 );\n\t\tif ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\n\t\t\t\tcontext.nodeType === 9 && documentIsHTML &&\n\t\t\t\tjQuery.expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( jQuery.expr.find.ID(\n\t\t\t\tunescapeSelector( token.matches[ 0 ] ),\n\t\t\t\tcontext\n\t\t\t) || [] )[ 0 ];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[ i ];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( jQuery.expr.relative[ ( type = token.type ) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( ( find = jQuery.expr.find[ type ] ) ) {\n\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( ( seed = find(\n\t\t\t\t\tunescapeSelector( token.matches[ 0 ] ),\n\t\t\t\t\trsibling.test( tokens[ 0 ].type ) &&\n\t\t\t\t\t\ttestContext( context.parentNode ) || context\n\t\t\t\t) ) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n}\n\n// Initialize against the default document\nsetDocument();\n\njQuery.find = find;\n\n// These have always been private, but they used to be documented as part of\n// Sizzle so let's maintain them for now for backwards compatibility purposes.\nfind.compile = compile;\nfind.select = select;\nfind.setDocument = setDocument;\nfind.tokenize = tokenize;\n\nfunction dir( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n}\n\nfunction siblings( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n}\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\n// rsingleTag matches a string consisting of a single HTML element with no attributes\n// and captures the element's name\nvar rsingleTag = /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i;\n\nfunction isObviousHtml( input ) {\n\treturn input[ 0 ] === \"<\" &&\n\t\tinput[ input.length - 1 ] === \">\" &&\n\t\tinput.length >= 3;\n}\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( typeof qualifier === \"function\" ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n// Initialize a jQuery object\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over to avoid XSS via location.hash (trac-9521)\n\t// Strict HTML recognition (trac-11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\tif ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( typeof selector === \"function\" ) {\n\t\t\treturn rootjQuery.ready !== undefined ?\n\t\t\t\trootjQuery.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\n\t\t} else {\n\n\t\t\t// Handle obvious HTML strings\n\t\t\tmatch = selector + \"\";\n\t\t\tif ( isObviousHtml( match ) ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip\n\t\t\t\t// the regex check. This also handles browser-supported HTML wrappers\n\t\t\t\t// like TrustedHTML.\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t// Handle HTML strings or selectors\n\t\t\t} else if ( typeof selector === \"string\" ) {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t} else {\n\t\t\t\treturn jQuery.makeArray( selector, this );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\t// Note: match[1] may be a string or a TrustedHTML wrapper\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document$1,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( typeof this[ match ] === \"function\" ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document$1.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr) & $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || rootjQuery ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\t\t}\n\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document$1 );\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to jQuery#find\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\tif ( elem.contentDocument != null &&\n\n\t\t\t// Support: IE 11+\n\t\t\t// elements with no `data` attribute has an object\n\t\t\t// `contentDocument` with a `null` prototype.\n\t\t\tgetProto( elem.contentDocument ) ) {\n\n\t\t\treturn elem.contentDocument;\n\t\t}\n\n\t\t// Support: IE 9 - 11+\n\t\t// Treat the template element as a regular one in browsers that\n\t\t// don't support it.\n\t\tif ( nodeName( elem, \"template\" ) ) {\n\t\t\telem = elem.content || elem;\n\t\t}\n\n\t\treturn jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( typeof arg === \"function\" ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && typeof( method = value.promise ) === \"function\" ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && typeof( method = value.then ) === \"function\" ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\t\treject( value );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\tcatch: function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( _i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = typeof fns[ tuple[ 4 ] ] === \"function\" &&\n\t\t\t\t\t\t\t\tfns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && typeof returned.promise === \"function\" ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( typeof then === \"function\" ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.error );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the error, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getErrorHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getErrorHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\ttypeof onProgress === \"function\" ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\ttypeof onFulfilled === \"function\" ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\ttypeof onRejected === \"function\" ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the primary Deferred\n\t\t\tprimary = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tprimary.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( primary.state() === \"pending\" ||\n\t\t\t\ttypeof( resolveValues[ i ] && resolveValues[ i ].then ) === \"function\" ) {\n\n\t\t\t\treturn primary.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );\n\t\t}\n\n\t\treturn primary.promise();\n\t}\n} );\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error\n// captured before the async barrier to get the original error cause\n// which may otherwise be hidden.\njQuery.Deferred.exceptionHook = function( error, asyncError ) {\n\n\tif ( error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn(\n\t\t\t\"jQuery.Deferred exception\",\n\t\t\terror,\n\t\t\tasyncError\n\t\t);\n\t}\n};\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See trac-6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document$1, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument$1.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\n// Catch cases where $(document).ready() is called\n// after the browser event has already occurred.\nif ( document$1.readyState !== \"loading\" ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument$1.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n// Matches dashed string for camelizing\nvar rdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( _all, letter ) {\n\treturn letter.toUpperCase();\n}\n\n// Convert dashed to camelCase\nfunction camelCase( string ) {\n\treturn string.replace( rdashAlpha, fcamelCase );\n}\n\n/**\n * Determines whether an object can have data\n */\nfunction acceptData( owner ) {\n\n\t// Accepts only:\n\t// - Node\n\t// - Node.ELEMENT_NODE\n\t// - Node.DOCUMENT_NODE\n\t// - Object\n\t// - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n}\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = Object.create( null );\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see trac-8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn value;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t// 1. No key was specified\n\t\t// 2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t// 1. The entire cache object\n\t\t// 2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t// 1. An object of properties\n\t\t// 2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\n\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11+\n\t\t\t\t\t\t// The attrs elements can be null (trac-14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.set( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.set( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\n\nvar pnum = /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/.source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\n// isHiddenWithinTree reports if an element has a non-\"none\" display style (inline and/or\n// through the CSS cascade), which is useful in deciding whether or not to make it visible.\n// It differs from the :hidden selector (jQuery.expr.pseudos.hidden) in two important ways:\n// * A hidden ancestor does not force an element to be classified as hidden.\n// * Being disconnected from the document does not force an element to be classified as hidden.\n// These differences improve the behavior of .toggle() et al. when applied to elements that are\n// detached or contained within hidden ancestors (gh-2404, gh-2863).\nfunction isHiddenWithinTree( elem, el ) {\n\n\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t// in that case, element will be second argument\n\telem = el || elem;\n\n\t// Inline style trumps all\n\treturn elem.style.display === \"none\" ||\n\t\telem.style.display === \"\" &&\n\t\tjQuery.css( elem, \"display\" ) === \"none\";\n}\n\nvar ralphaStart = /^[a-z]/,\n\n\t// The regex visualized:\n\t//\n\t// /----------\\\n\t// | | /-------\\\n\t// | / Top \\ | | |\n\t// /--- Border ---+-| Right |-+---+- Width -+---\\\n\t// | | Bottom | |\n\t// | \\ Left / |\n\t// | |\n\t// | /----------\\ |\n\t// | /-------------\\ | | |- END\n\t// | | | | / Top \\ | |\n\t// | | / Margin \\ | | | Right | | |\n\t// |---------+-| |-+---+-| Bottom |-+----|\n\t// | \\ Padding / \\ Left / |\n\t// BEGIN -| |\n\t// | /---------\\ |\n\t// | | | |\n\t// | | / Min \\ | / Width \\ |\n\t// \\--------------+-| |-+---| |---/\n\t// \\ Max / \\ Height /\n\trautoPx = /^(?:Border(?:Top|Right|Bottom|Left)?(?:Width|)|(?:Margin|Padding)?(?:Top|Right|Bottom|Left)?|(?:Min|Max)?(?:Width|Height))$/;\n\nfunction isAutoPx( prop ) {\n\n\t// The first test is used to ensure that:\n\t// 1. The prop starts with a lowercase letter (as we uppercase it for the second regex).\n\t// 2. The prop is not empty.\n\treturn ralphaStart.test( prop ) &&\n\t\trautoPx.test( prop[ 0 ].toUpperCase() + prop.slice( 1 ) );\n}\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( isAutoPx( prop ) ? \"px\" : \"\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = elem.nodeType &&\n\t\t\t( !isAutoPx( prop ) || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Support: Firefox <=54 - 66+\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/;\n\n// Convert dashed to camelCase, handle vendor prefixes.\n// Used by the css & effects modules.\n// Support: IE <=9 - 11+\n// Microsoft forgot to hump their vendor prefix (trac-9572)\nfunction cssCamelCase( string ) {\n\treturn camelCase( string.replace( rmsPrefix, \"ms-\" ) );\n}\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\n\nvar isAttached = function( elem ) {\n\t\treturn jQuery.contains( elem.ownerDocument, elem ) ||\n\t\t\telem.getRootNode( composed ) === elem.ownerDocument;\n\t},\n\tcomposed = { composed: true };\n\n// Support: IE 9 - 11+\n// Check attachment across shadow DOM boundaries when possible (gh-3504).\n// Provide a fallback for browsers without Shadow DOM v1 support.\nif ( !documentElement$1.getRootNode ) {\n\tisAttached = function( elem ) {\n\t\treturn jQuery.contains( elem.ownerDocument, elem );\n\t};\n}\n\n// rtagName captures the name from the first start tag in a string of HTML\n// https://html.spec.whatwg.org/multipage/syntax.html#tag-open-state\n// https://html.spec.whatwg.org/multipage/syntax.html#tag-name-state\nvar rtagName = /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i;\n\nvar wrapMap = {\n\n\t// Table parts need to be wrapped with `` or they're\n\t// stripped to their contents when put in a div.\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do, so we cannot shorten\n\t// this by omitting or other required elements.\n\tthead: [ \"table\" ],\n\tcol: [ \"colgroup\", \"table\" ],\n\ttr: [ \"tbody\", \"table\" ],\n\ttd: [ \"tr\", \"tbody\", \"table\" ]\n};\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11+\n\t// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\n\t\t// Use slice to snapshot the live collection from gEBTN\n\t\tret = arr.slice.call( context.getElementsByTagName( tag || \"*\" ) );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\nvar rscriptType = /^$|^module$|\\/(?:java|ecma)script/i;\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, attached, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( toType( elem ) === \"object\" && ( elem.nodeType || isArrayLike( elem ) ) ) {\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || arr;\n\n\t\t\t\t// Create wrappers & descend into them.\n\t\t\t\tj = wrap.length;\n\t\t\t\twhile ( --j > -1 ) {\n\t\t\t\t\ttmp = tmp.appendChild( context.createElement( wrap[ j ] ) );\n\t\t\t\t}\n\n\t\t\t\ttmp.innerHTML = jQuery.htmlPrefilter( elem );\n\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (trac-12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tattached = isAttached( elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( attached ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = flat( args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tvalueIsFunction = typeof value === \"function\";\n\n\tif ( valueIsFunction ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (trac-8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Re-enable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.get( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src && ( node.type || \"\" ).toLowerCase() !== \"module\" ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl && !node.noModule ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src, {\n\t\t\t\t\t\t\t\t\tnonce: node.nonce,\n\t\t\t\t\t\t\t\t\tcrossOrigin: node.crossOrigin\n\t\t\t\t\t\t\t\t}, doc );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tDOMEval( node.textContent, node, doc );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nvar rcheckableType = /^(?:checkbox|radio)$/i;\n\nvar rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Only attach events to objects that accept data\n\t\tif ( !acceptData( elem ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement$1, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = Object.create( null );\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\n\t\t\t// Make a writable jQuery.Event from the native event object\n\t\t\tevent = jQuery.event.fix( nativeEvent ),\n\n\t\t\thandlers = (\n\t\t\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\t\t)[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// If the event is namespaced, then each handler is only invoked if it is\n\t\t\t\t// specially universal or its namespaces are a superset of the event's.\n\t\t\t\tif ( !event.rnamespace || handleObj.namespace === false ||\n\t\t\t\t\tevent.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: Firefox <=42 - 66+\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11+\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (trac-13208)\n\t\t\t\t// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (trac-13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: typeof hook === \"function\" ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: jQuery.extend( Object.create( null ), {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tclick: {\n\n\t\t\t// Utilize native event to ensure correct state for checkable inputs\n\t\t\tsetup: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Claim the first handler\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\t// dataPriv.set( el, \"click\", ... )\n\t\t\t\t\tleverageNative( el, \"click\", true );\n\t\t\t\t}\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\ttrigger: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Force setup before triggering a click\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\tleverageNative( el, \"click\" );\n\t\t\t\t}\n\n\t\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\t\treturn true;\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, suppress native .click() on links\n\t\t\t// Also prevent it if we're currently inside a leveraged native-event stack\n\t\t\t_default: function( event ) {\n\t\t\t\tvar target = event.target;\n\t\t\t\treturn rcheckableType.test( target.type ) &&\n\t\t\t\t\ttarget.click && nodeName( target, \"input\" ) &&\n\t\t\t\t\tdataPriv.get( target, \"click\" ) ||\n\t\t\t\t\tnodeName( target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\t\t\t\tif ( event.result !== undefined ) {\n\n\t\t\t\t\t// Setting `event.originalEvent.returnValue` in modern\n\t\t\t\t\t// browsers does the same as just calling `preventDefault()`,\n\t\t\t\t\t// the browsers ignore the value anyway.\n\t\t\t\t\t// Incidentally, IE 11 is the only browser from our supported\n\t\t\t\t\t// ones which respects the value returned from a `beforeunload`\n\t\t\t\t\t// handler attached by `addEventListener`; other browsers do\n\t\t\t\t\t// so only for inline handlers, so not setting the value\n\t\t\t\t\t// directly shouldn't reduce any functionality.\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t} )\n};\n\n// Ensure the presence of an event listener that handles manually-triggered\n// synthetic events by interrupting progress until reinvoked in response to\n// *native* events that it fires directly, ensuring that state changes have\n// already occurred before other listeners are invoked.\nfunction leverageNative( el, type, isSetup ) {\n\n\t// Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !isSetup ) {\n\t\tif ( dataPriv.get( el, type ) === undefined ) {\n\t\t\tjQuery.event.add( el, type, returnTrue );\n\t\t}\n\t\treturn;\n\t}\n\n\t// Register the controller as a special universal handler for all event namespaces\n\tdataPriv.set( el, type, false );\n\tjQuery.event.add( el, type, {\n\t\tnamespace: false,\n\t\thandler: function( event ) {\n\t\t\tvar result,\n\t\t\t\tsaved = dataPriv.get( this, type );\n\n\t\t\t// This controller function is invoked under multiple circumstances,\n\t\t\t// differentiated by the stored value in `saved`:\n\t\t\t// 1. For an outer synthetic `.trigger()`ed event (detected by\n\t\t\t// `event.isTrigger & 1` and non-array `saved`), it records arguments\n\t\t\t// as an array and fires an [inner] native event to prompt state\n\t\t\t// changes that should be observed by registered listeners (such as\n\t\t\t// checkbox toggling and focus updating), then clears the stored value.\n\t\t\t// 2. For an [inner] native event (detected by `saved` being\n\t\t\t// an array), it triggers an inner synthetic event, records the\n\t\t\t// result, and preempts propagation to further jQuery listeners.\n\t\t\t// 3. For an inner synthetic event (detected by `event.isTrigger & 1` and\n\t\t\t// array `saved`), it prevents double-propagation of surrogate events\n\t\t\t// but otherwise allows everything to proceed (particularly including\n\t\t\t// further listeners).\n\t\t\t// Possible `saved` data shapes: `[...], `{ value }`, `false`.\n\t\t\tif ( ( event.isTrigger & 1 ) && this[ type ] ) {\n\n\t\t\t\t// Interrupt processing of the outer synthetic .trigger()ed event\n\t\t\t\tif ( !saved.length ) {\n\n\t\t\t\t\t// Store arguments for use when handling the inner native event\n\t\t\t\t\t// There will always be at least one argument (an event object),\n\t\t\t\t\t// so this array will not be confused with a leftover capture object.\n\t\t\t\t\tsaved = slice.call( arguments );\n\t\t\t\t\tdataPriv.set( this, type, saved );\n\n\t\t\t\t\t// Trigger the native event and capture its result\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tdataPriv.set( this, type, false );\n\n\t\t\t\t\tif ( saved !== result ) {\n\n\t\t\t\t\t\t// Cancel the outer synthetic event\n\t\t\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t\t\t\tevent.preventDefault();\n\n\t\t\t\t\t\t// Support: Chrome 86+\n\t\t\t\t\t\t// In Chrome, if an element having a focusout handler is\n\t\t\t\t\t\t// blurred by clicking outside of it, it invokes the handler\n\t\t\t\t\t\t// synchronously. If that handler calls `.remove()` on\n\t\t\t\t\t\t// the element, the data is cleared, leaving `result`\n\t\t\t\t\t\t// undefined. We need to guard against this.\n\t\t\t\t\t\treturn result && result.value;\n\t\t\t\t\t}\n\n\t\t\t\t// If this is an inner synthetic event for an event with a bubbling\n\t\t\t\t// surrogate (focus or blur), assume that the surrogate already\n\t\t\t\t// propagated from triggering the native event and prevent that\n\t\t\t\t// from happening again here.\n\t\t\t\t} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\n\t\t\t// If this is a native event triggered above, everything is now in order.\n\t\t\t// Fire an inner synthetic event with the original arguments.\n\t\t\t} else if ( saved.length ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, {\n\t\t\t\t\tvalue: jQuery.event.trigger(\n\t\t\t\t\t\tsaved[ 0 ],\n\t\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\t\tthis\n\t\t\t\t\t)\n\t\t\t\t} );\n\n\t\t\t\t// Abort handling of the native event by all jQuery handlers while allowing\n\t\t\t\t// native handlers on the same element to run. On target, this is achieved\n\t\t\t\t// by stopping immediate propagation just on the jQuery event. However,\n\t\t\t\t// the native event is re-wrapped by a jQuery one on each level of the\n\t\t\t\t// propagation so the only way to stop it for jQuery is to stop it for\n\t\t\t\t// everyone via native `stopPropagation()`. This is not a problem for\n\t\t\t\t// focus/blur which don't bubble, but it does also stop click on checkboxes\n\t\t\t\t// and radios. We accept this limitation.\n\t\t\t\tevent.stopPropagation();\n\t\t\t\tevent.isImmediatePropagationStopped = returnTrue;\n\t\t\t}\n\t\t}\n\t} );\n}\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\tthis.target = src.target;\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || Date.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcode: true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\twhich: true\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\n\n\t// Support: IE 11+\n\t// Attach a single focusin/focusout handler on the document while someone wants focus/blur.\n\t// This is because the former are synchronous in IE while the latter are async. In other\n\t// browsers, all those handlers are invoked synchronously.\n\tfunction focusMappedHandler( nativeEvent ) {\n\n\t\t// `eventHandle` would already wrap the event, but we need to change the `type` here.\n\t\tvar event = jQuery.event.fix( nativeEvent );\n\t\tevent.type = nativeEvent.type === \"focusin\" ? \"focus\" : \"blur\";\n\t\tevent.isSimulated = true;\n\n\t\t// focus/blur don't bubble while focusin/focusout do; simulate the former by only\n\t\t// invoking the handler at the lower level.\n\t\tif ( event.target === event.currentTarget ) {\n\n\t\t\t// The setup part calls `leverageNative`, which, in turn, calls\n\t\t\t// `jQuery.event.add`, so event handle will already have been set\n\t\t\t// by this point.\n\t\t\tdataPriv.get( this, \"handle\" )( event );\n\t\t}\n\t}\n\n\tjQuery.event.special[ type ] = {\n\n\t\t// Utilize native event if possible so blur/focus sequence is correct\n\t\tsetup: function() {\n\n\t\t\t// Claim the first handler\n\t\t\t// dataPriv.set( this, \"focus\", ... )\n\t\t\t// dataPriv.set( this, \"blur\", ... )\n\t\t\tleverageNative( this, type, true );\n\n\t\t\tif ( isIE ) {\n\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t} else {\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\t\ttrigger: function() {\n\n\t\t\t// Force setup before trigger\n\t\t\tleverageNative( this, type );\n\n\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\treturn true;\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tif ( isIE ) {\n\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t} else {\n\n\t\t\t\t// Return false to indicate standard teardown should be applied\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\n\t\t// Suppress native focus or blur if we're currently inside\n\t\t// a leveraged native-event stack\n\t\t_default: function( event ) {\n\t\t\treturn dataPriv.get( event.target, type );\n\t\t},\n\n\t\tdelegateType: delegateType\n\t};\n} );\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event ) dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\nvar\n\n\t// Support: IE <=10 - 11+\n\t// In IE using regex groups here causes severe slowdowns.\n\trnoInnerhtml = / 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\t\t\tpush.apply( ret, elems );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\n\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar rcustomProp = /^--/;\n\nfunction getStyles( elem ) {\n\n\t// Support: IE <=11+ (trac-14150)\n\t// In IE popup's `window` is the opener window which makes `window.getComputedStyle( elem )`\n\t// break. Using `elem.ownerDocument.defaultView` avoids the issue.\n\tvar view = elem.ownerDocument.defaultView;\n\n\t// `document.implementation.createHTMLDocument( \"\" )` has a `null` `defaultView`\n\t// property; check `defaultView` truthiness to fallback to window in such a case.\n\tif ( !view ) {\n\t\tview = window;\n\t}\n\n\treturn view.getComputedStyle( elem );\n}\n\n// A method for quickly swapping in/out CSS properties to get correct calculations.\nfunction swap( elem, options, callback ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.call( elem );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n}\n\nfunction curCSS( elem, name, computed ) {\n\tvar ret,\n\t\tisCustomProp = rcustomProp.test( name );\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for `.css('--customProperty')` (gh-3144)\n\tif ( computed ) {\n\n\t\t// A fallback to direct property access is needed as `computed`, being\n\t\t// the output of `getComputedStyle`, contains camelCased keys and\n\t\t// `getPropertyValue` requires kebab-case ones.\n\t\t//\n\t\t// Support: IE <=9 - 11+\n\t\t// IE only supports `\"float\"` in `getPropertyValue`; in computed styles\n\t\t// it's only available as `\"cssFloat\"`. We no longer modify properties\n\t\t// sent to `.css()` apart from camelCasing, so we need to check both.\n\t\t// Normally, this would create difference in behavior: if\n\t\t// `getPropertyValue` returns an empty string, the value returned\n\t\t// by `.css()` would be `undefined`. This is usually the case for\n\t\t// disconnected elements. However, in IE even disconnected elements\n\t\t// with no styles return `\"none\"` for `getPropertyValue( \"float\" )`\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( isCustomProp && ret ) {\n\n\t\t\t// Support: Firefox 105 - 135+\n\t\t\t// Spec requires trimming whitespace for custom properties (gh-4926).\n\t\t\t// Firefox only trims leading whitespace.\n\t\t\t//\n\t\t\t// Fall back to `undefined` if empty string returned.\n\t\t\t// This collapses a missing definition with property defined\n\t\t\t// and set to an empty string but there's no standard API\n\t\t\t// allowing us to differentiate them without a performance penalty\n\t\t\t// and returning `undefined` aligns with older jQuery.\n\t\t\t//\n\t\t\t// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED\n\t\t\t// as whitespace while CSS does not, but this is not a problem\n\t\t\t// because CSS preprocessing replaces them with U+000A LINE FEED\n\t\t\t// (which *is* CSS whitespace)\n\t\t\t// https://www.w3.org/TR/css-syntax-3/#input-preprocessing\n\t\t\tret = ret.replace( rtrimCSS, \"$1\" ) || undefined;\n\t\t}\n\n\t\tif ( ret === \"\" && !isAttached( elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11+\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\nvar cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document$1.createElement( \"div\" ).style;\n\n// Return a vendor-prefixed property or undefined\nfunction vendorPropName( name ) {\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a potentially-mapped vendor prefixed property\nfunction finalPropName( name ) {\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\treturn vendorPropName( name ) || name;\n}\n\nvar reliableTrDimensionsVal, reliableColDimensionsVal,\n\ttable = document$1.createElement( \"table\" );\n\n// Executing table tests requires only one layout, so they're executed\n// at the same time to save the second computation.\nfunction computeTableStyleTests() {\n\tif (\n\n\t\t// This is a singleton, we need to execute it only once\n\t\t!table ||\n\n\t\t// Finish early in limited (non-browser) environments\n\t\t!table.style\n\t) {\n\t\treturn;\n\t}\n\n\tvar trStyle,\n\t\tcol = document$1.createElement( \"col\" ),\n\t\ttr = document$1.createElement( \"tr\" ),\n\t\ttd = document$1.createElement( \"td\" );\n\n\ttable.style.cssText = \"position:absolute;left:-11111px;\" +\n\t\t\"border-collapse:separate;border-spacing:0\";\n\ttr.style.cssText = \"box-sizing:content-box;border:1px solid;height:1px\";\n\ttd.style.cssText = \"height:9px;width:9px;padding:0\";\n\n\tcol.span = 2;\n\n\tdocumentElement$1\n\t\t.appendChild( table )\n\t\t.appendChild( col )\n\t\t.parentNode\n\t\t.appendChild( tr )\n\t\t.appendChild( td )\n\t\t.parentNode\n\t\t.appendChild( td.cloneNode( true ) );\n\n\t// Don't run until window is visible\n\tif ( table.offsetWidth === 0 ) {\n\t\tdocumentElement$1.removeChild( table );\n\t\treturn;\n\t}\n\n\ttrStyle = window.getComputedStyle( tr );\n\n\t// Support: Firefox 135+\n\t// Firefox always reports computed width as if `span` was 1.\n\t// Support: Safari 18.3+\n\t// In Safari, computed width for columns is always 0.\n\t// In both these browsers, using `offsetWidth` solves the issue.\n\t// Support: IE 11+\n\t// In IE, `` computed width is `\"auto\"` unless `width` is set\n\t// explicitly via CSS so measurements there remain incorrect. Because of\n\t// the lack of a proper workaround, we accept this limitation, treating\n\t// IE as passing the test.\n\treliableColDimensionsVal = isIE || Math.round( parseFloat(\n\t\twindow.getComputedStyle( col ).width )\n\t) === 18;\n\n\t// Support: IE 10 - 11+\n\t// IE misreports `getComputedStyle` of table rows with width/height\n\t// set in CSS while `offset*` properties report correct values.\n\t// Support: Firefox 70 - 135+\n\t// Only Firefox includes border widths\n\t// in computed dimensions for table rows. (gh-4529)\n\treliableTrDimensionsVal = Math.round( parseFloat( trStyle.height ) +\n\t\tparseFloat( trStyle.borderTopWidth ) +\n\t\tparseFloat( trStyle.borderBottomWidth ) ) === tr.offsetHeight;\n\n\tdocumentElement$1.removeChild( table );\n\n\t// Nullify the table so it wouldn't be stored in the memory;\n\t// it will also be a sign that checks were already performed.\n\ttable = null;\n}\n\njQuery.extend( support, {\n\treliableTrDimensions: function() {\n\t\tcomputeTableStyleTests();\n\t\treturn reliableTrDimensionsVal;\n\t},\n\n\treliableColDimensions: function() {\n\t\tcomputeTableStyleTests();\n\t\treturn reliableColDimensionsVal;\n\t}\n} );\n\nvar cssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t};\n\nfunction setPositiveNumber( _elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0,\n\t\tmarginDelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\t// Count margin delta separately to only add it after scroll gutter adjustment.\n\t\t// This is needed to make negative margins work with `outerHeight( true )` (gh-3982).\n\t\tif ( box === \"margin\" ) {\n\t\t\tmarginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\n\t\t// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n\t\t// Use an explicit zero to avoid NaN (gh-3964)\n\t\t) ) || 0;\n\t}\n\n\treturn delta + marginDelta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\n\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n\t\t// Fake content-box until we know it's needed to know the true value.\n\t\tboxSizingNeeded = isIE || extra,\n\t\tisBorderBox = boxSizingNeeded &&\n\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox,\n\n\t\tval = curCSS( elem, dimension, styles ),\n\t\toffsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\n\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\n\tif (\n\t\t(\n\n\t\t\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t\t\t// This happens for inline elements with no explicit setting (gh-3571)\n\t\t\tval === \"auto\" ||\n\n\t\t\t// Support: IE 9 - 11+\n\t\t\t// Use offsetWidth/offsetHeight for when box sizing is unreliable.\n\t\t\t// In those cases, the computed value can be trusted to be border-box.\n\t\t\t( isIE && isBorderBox ) ||\n\n\t\t\t( !support.reliableColDimensions() && nodeName( elem, \"col\" ) ) ||\n\n\t\t\t( !support.reliableTrDimensions() && nodeName( elem, \"tr\" ) )\n\t\t) &&\n\n\t\t// Make sure the element is visible & connected\n\t\telem.getClientRects().length ) {\n\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t\t// Where available, offsetWidth/offsetHeight approximate border box dimensions.\n\t\t// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n\t\t// retrieved value as a content box dimension.\n\t\tvalueIsBorderBox = offsetProp in elem;\n\t\tif ( valueIsBorderBox ) {\n\t\t\tval = elem[ offsetProp ];\n\t\t}\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = cssCamelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (trac-7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug trac-9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (trac-7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If the value is a number, add `px` for certain CSS properties\n\t\t\tif ( type === \"number\" ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( isAutoPx( origName ) ? \"px\" : \"\" );\n\t\t\t}\n\n\t\t\t// Support: IE <=9 - 11+\n\t\t\t// background-* props of a cloned element affect the source element (trac-8908)\n\t\t\tif ( isIE && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = cssCamelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( _i, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Elements with `display: none` can have dimension info if\n\t\t\t\t// we invisibly show them.\n\t\t\t\treturn jQuery.css( elem, \"display\" ) === \"none\" ?\n\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t} ) :\n\t\t\t\t\tgetWidthOrHeight( elem, dimension, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = getStyles( elem ),\n\n\t\t\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n\t\t\t\tisBorderBox = extra &&\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra ?\n\t\t\t\t\tboxModelAdjustment(\n\t\t\t\t\t\telem,\n\t\t\t\t\t\tdimension,\n\t\t\t\t\t\textra,\n\t\t\t\t\t\tisBorderBox,\n\t\t\t\t\t\tstyles\n\t\t\t\t\t) :\n\t\t\t\t\t0;\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( prefix !== \"margin\" ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( isAutoPx( prop ) ? \"px\" : \"\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 && (\n\t\t\t\tjQuery.cssHooks[ tween.prop ] ||\n\t\t\t\t\ttween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document$1.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, 13 );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = Date.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11+\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY.\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.set( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t// eslint-disable-next-line no-loop-func\n\t\t\tanim.done( function() {\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = cssCamelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\tpercent = 1 - ( remaining / animation.duration || 0 ),\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( typeof result.stop === \"function\" ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( typeof animation.opts.start === \"function\" ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( typeof props === \"function\" ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || easing ||\n\t\t\ttypeof speed === \"function\" && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && typeof easing !== \"function\" && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( typeof opt.old === \"function\" ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\n\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( _i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = Date.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n// Based off of the plugin by Clint Helfers, with permission.\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11+\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// Use proper attribute retrieval (trac-12072)\n\t\t\t\tvar tabindex = elem.getAttribute( \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\n\t\t\t\t\t// href-less anchor's `tabIndex` property value is `0` and\n\t\t\t\t\t// the `tabindex` attribute value: `null`. We want `-1`.\n\t\t\t\t\trclickable.test( elem.nodeName ) && elem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11+\n// Accessing the selectedIndex property forces the browser to respect\n// setting selected on the option. The getter ensures a default option\n// is selected when in an optgroup. ESLint rule \"no-unused-expressions\"\n// is disabled for this code since it considers such accessions noop.\nif ( isIE ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n// Strip and collapse whitespace according to HTML spec\n// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\nfunction stripAndCollapse( value ) {\n\tvar tokens = value.match( rnothtmlwhite ) || [];\n\treturn tokens.join( \" \" );\n}\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( typeof value === \"function\" ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + className + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += className + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( typeof value === \"function\" ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + className + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + className + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar classNames, className, i, self;\n\n\t\tif ( typeof value === \"function\" ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof stateVal === \"boolean\" ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\tself = jQuery( this );\n\n\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, valueIsFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tvalueIsFunction = typeof value === \"function\";\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\tif ( option.selected &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\tif ( ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery( option ).val(), values ) > -1\n\t\t\t\t\t) ) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\nif ( isIE ) {\n\tjQuery.valHooks.option = {\n\t\tget: function( elem ) {\n\n\t\t\tvar val = elem.getAttribute( \"value\" );\n\t\t\treturn val != null ?\n\t\t\t\tval :\n\n\t\t\t\t// Support: IE <=10 - 11+\n\t\t\t\t// option.text throws exceptions (trac-14686, trac-14858)\n\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t}\n\t};\n}\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n} );\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\n\t\t\teventPath = [ elem || document$1 ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = lastElement = tmp = elem = elem || document$1;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (trac-9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document$1 ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tlastElement = cur;\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || Object.create( null ) )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (trac-6170)\n\t\t\t\tif ( ontype && typeof elem[ type ] === \"function\" && !isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\nvar location = window.location;\n\nvar nonce = { guid: Date.now() };\n\nvar rquery = /\\?/;\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, parserErrorElem;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11+\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {}\n\n\tparserErrorElem = xml && xml.getElementsByTagName( \"parsererror\" )[ 0 ];\n\tif ( !xml || parserErrorElem ) {\n\t\tjQuery.error( \"Invalid XML: \" + (\n\t\t\tparserErrorElem ?\n\t\t\t\tjQuery.map( parserErrorElem.childNodes, function( el ) {\n\t\t\t\t\treturn el.textContent;\n\t\t\t\t} ).join( \"\\n\" ) :\n\t\t\t\tdata\n\t\t) );\n\t}\n\treturn xml;\n};\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && toType( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = typeof valueOrFunction === \"function\" ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\tif ( a == null ) {\n\t\treturn \"\";\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} ).filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} ).map( function( _i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// trac-7653, trac-8125, trac-8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t * - BEFORE asking for a transport\n\t * - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document$1.createElement( \"a\" );\n\noriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( typeof func === \"function\" ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes trac-9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\n\t\t\t\t\t\t\t\t// Support: IE 11+\n\t\t\t\t\t\t\t\t// `getResponseHeader( key )` in IE doesn't combine all header\n\t\t\t\t\t\t\t\t// values for the provided key into a single result with values\n\t\t\t\t\t\t\t\t// joined by commas as other browsers do. Instead, it returns\n\t\t\t\t\t\t\t\t// them on separate lines.\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() + \" \" ] =\n\t\t\t\t\t\t\t\t\t( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\n\t\t\t\t\t\t\t\t\t\t.concat( match[ 2 ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() + \" \" ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match.join( \", \" );\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (trac-10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket trac-12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document$1.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11+\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11+\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an ESM-usage scenario (trac-15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// trac-9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" +\n\t\t\t\t\t( nonce.guid++ ) + uncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Use a noop converter for missing script but not if jsonp\n\t\t\tif ( !isSuccess &&\n\t\t\t\tjQuery.inArray( \"script\", s.dataTypes ) > -1 &&\n\t\t\t\tjQuery.inArray( \"json\", s.dataTypes ) < 0 ) {\n\t\t\t\ts.converters[ \"text script\" ] = function() {};\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( _i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted.\n\t\t// Handle the null callback placeholder.\n\t\tif ( typeof data === \"function\" || data === null ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\njQuery.ajaxPrefilter( function( s ) {\n\tvar i;\n\tfor ( i in s.headers ) {\n\t\tif ( i.toLowerCase() === \"content-type\" ) {\n\t\t\ts.contentType = s.headers[ i ] || \"\";\n\t\t}\n\t}\n} );\n\njQuery._evalUrl = function( url, options, doc ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (trac-11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\t\tscriptAttrs: options.crossOrigin ? { \"crossOrigin\": options.crossOrigin } : undefined,\n\n\t\t// Only evaluate the response if it is successful (gh-4126)\n\t\t// dataFilter is not invoked for failure responses, so using it instead\n\t\t// of the default converter is kludgy but it works.\n\t\tconverters: {\n\t\t\t\"text script\": function() {}\n\t\t},\n\t\tdataFilter: function( response ) {\n\t\t\tjQuery.globalEval( response, options, doc );\n\t\t}\n\t} );\n};\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( typeof html === \"function\" ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( typeof html === \"function\" ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar htmlIsFunction = typeof html === \"function\";\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\njQuery.ajaxSettings.xhr = function() {\n\treturn new window.XMLHttpRequest();\n};\n\nvar xhrSuccessStatus = {\n\n\t// File protocol always yields status code 0, assume 200\n\t0: 200\n};\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback;\n\n\treturn {\n\t\tsend: function( headers, complete ) {\n\t\t\tvar i,\n\t\t\t\txhr = options.xhr();\n\n\t\t\txhr.open(\n\t\t\t\toptions.type,\n\t\t\t\toptions.url,\n\t\t\t\toptions.async,\n\t\t\t\toptions.username,\n\t\t\t\toptions.password\n\t\t\t);\n\n\t\t\t// Apply custom fields if provided\n\t\t\tif ( options.xhrFields ) {\n\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override mime type if needed\n\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t}\n\n\t\t\t// X-Requested-With header\n\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t}\n\n\t\t\t// Set headers\n\t\t\tfor ( i in headers ) {\n\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t}\n\n\t\t\t// Callback\n\t\t\tcallback = function( type ) {\n\t\t\t\treturn function() {\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tcallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = null;\n\n\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see trac-8605, trac-14207\n\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) === \"text\" ?\n\t\t\t\t\t\t\t\t\t{ text: xhr.responseText } :\n\t\t\t\t\t\t\t\t\t{ binary: xhr.response },\n\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t\t// Listen to events\n\t\t\txhr.onload = callback();\n\t\t\txhr.onabort = xhr.onerror = xhr.ontimeout = callback( \"error\" );\n\n\t\t\t// Create the abort callback\n\t\t\tcallback = callback( \"abort\" );\n\n\t\t\ttry {\n\n\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// trac-14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\tabort: function() {\n\t\t\tif ( callback ) {\n\t\t\t\tcallback();\n\t\t\t}\n\t\t}\n\t};\n} );\n\nfunction canUseScriptTag( s ) {\n\n\t// A script tag can only be used for async, cross domain or forced-by-attrs requests.\n\t// Requests with headers cannot use a script tag. However, when both `scriptAttrs` &\n\t// `headers` options are specified, both are impossible to satisfy together; we\n\t// prefer `scriptAttrs` then.\n\t// Sync requests remain handled differently to preserve strict script ordering.\n\treturn s.scriptAttrs || (\n\t\t!s.headers &&\n\t\t(\n\t\t\ts.crossDomain ||\n\n\t\t\t// When dealing with JSONP (`s.dataTypes` include \"json\" then)\n\t\t\t// don't use a script tag so that error responses still may have\n\t\t\t// `responseJSON` set. Continue using a script tag for JSONP requests that:\n\t\t\t// * are cross-domain as AJAX requests won't work without a CORS setup\n\t\t\t// * have `scriptAttrs` set as that's a script-only functionality\n\t\t\t// Note that this means JSONP requests violate strict CSP script-src settings.\n\t\t\t// A proper solution is to migrate from using JSONP to a CORS setup.\n\t\t\t( s.async && jQuery.inArray( \"json\", s.dataTypes ) < 0 )\n\t\t)\n\t);\n}\n\n// Install script dataType. Don't specify `contents.script` so that an explicit\n// `dataType: \"script\"` is required (see gh-2432, gh-4822)\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\n\t// These types of requests are handled via a script tag\n\t// so force their methods to GET.\n\tif ( canUseScriptTag( s ) ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\tif ( canUseScriptTag( s ) ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"\n \n \n `);\n document.close();\n}\n\nconst delay = (ms: number) => new Promise((resolve) => { setTimeout(resolve, ms); });\n\nexport async function restartReload(initial = true) {\n document.body.style = 'background: #222222; font-size: 1rem; font-family:monospace; margin-top:20%; color:lightgray; text-align:center';\n document.body.innerHTML = '

Server shutdown in progress...

';\n if (initial) await delay(10000);\n try {\n const res = await authFetch(`${window.api}/progress?skip_current_image=true`);\n console.log('restartReload', res);\n if (res?.ok) {\n document.body.innerHTML = '

Server restart in progress...

';\n setTimeout(() => location.reload(), 10000);\n } else {\n setTimeout(() => restartReload(false), 2500);\n }\n } catch {\n setTimeout(() => restartReload(false), 2500);\n }\n return [];\n}\n\nexport function updateInput(target) {\n const e = new Event('input', { bubbles: true });\n Object.defineProperty(e, 'target', { value: target });\n target.dispatchEvent(e);\n}\n\nlet desiredCheckpointName = null;\nexport function selectCheckpoint(name) {\n desiredCheckpointName = name;\n const tabName = getENActiveTab();\n const btnModel = gradioApp().getElementById(`${tabName}_extra_model`);\n const isRefiner = btnModel && btnModel.classList.contains('toolbutton-selected');\n if (isRefiner) gradioApp().getElementById('change_refiner').click();\n else gradioApp().getElementById('change_checkpoint').click();\n log(`selectCheckpoint ${isRefiner ? 'refiner' : 'model'}: ${desiredCheckpointName}`);\n markSelectedCards([desiredCheckpointName], 'model');\n setTimeout(requestProgress, 250);\n}\n\nlet desiredVAEName = null;\nexport function selectVAE(name) {\n desiredVAEName = name;\n gradioApp().getElementById('change_vae').click();\n log(`selectVAE: ${desiredVAEName}`);\n markSelectedCards([desiredVAEName], 'vae');\n}\n\nlet desiredUNetName = null;\n\nfunction consumeDesiredCheckpointName(v) {\n const res = desiredCheckpointName;\n desiredCheckpointName = null;\n return [res || v, null];\n}\n\nfunction consumeDesiredVAEName(v) {\n const res = desiredVAEName;\n desiredVAEName = null;\n return [res || v, null];\n}\n\nfunction consumeDesiredUNetName(v) {\n const res = desiredUNetName;\n desiredUNetName = null;\n return [res || v, null];\n}\n\nfunction getDesiredCheckpointName() {\n return desiredCheckpointName;\n}\n\nexport function selectUNet(name) {\n desiredUNetName = name;\n gradioApp().getElementById('change_unet').click();\n log(`selectUNet: ${desiredUNetName}`);\n markSelectedCards([desiredUNetName], 'unet');\n}\n\nexport function selectReference(name) {\n log(`selectReference: ${name}`);\n desiredCheckpointName = name;\n gradioApp().getElementById('change_reference').click();\n markSelectedCards([desiredCheckpointName], 'model');\n setTimeout(requestProgress, 250);\n}\n\nfunction currentImageResolutionimg2img(_a, _b, scaleBy) {\n const img = gradioApp().querySelector('#mode_img2img > div[style=\"display: block;\"] img');\n return img ? [img.naturalWidth, img.naturalHeight, scaleBy] : [0, 0, scaleBy];\n}\n\nfunction currentImageResolutioncontrol(_a, _b, scaleBy) {\n if (window.kanvas) {\n const active = window.kanvas.stages?.getActiveStage();\n return [active?.width || 0, active?.height || 0, scaleBy];\n }\n const img = gradioApp().querySelector('#control-tab-input > div[style=\"display: block;\"] img');\n return img ? [img.naturalWidth, img.naturalHeight, scaleBy] : [0, 0, scaleBy];\n}\n\nfunction updateImg2imgResizeToTextAfterChangingImage() {\n const el = gradioApp().getElementById('img2img_update_resize_to');\n if (el) setTimeout(() => gradioApp().getElementById('img2img_update_resize_to').click(), 500);\n return [];\n}\n\nfunction createThemeElement(): HTMLImageElement {\n const el = document.createElement('img');\n el.id = 'theme-preview';\n el.className = 'theme-preview';\n el.onclick = () => { el.style.display = 'none'; };\n document.body.appendChild(el);\n return el;\n}\n\nexport async function toggleCompact(val, old) {\n if (val === old) return;\n log('toggleCompact', val, old);\n if (val) {\n gradioApp().style.setProperty('--layout-gap', 'var(--spacing-md)');\n gradioApp().querySelectorAll('input[type=range]').forEach((el) => el.classList.add('hidden'));\n gradioApp().querySelectorAll('div .form').forEach((el) => el.classList.add('form-compact'));\n gradioApp().querySelectorAll('.small-accordion .label-wrap').forEach((el) => el.classList.add('accordion-compact'));\n } else {\n gradioApp().style.setProperty('--layout-gap', 'var(--spacing-xxl)');\n gradioApp().querySelectorAll('input[type=range]').forEach((el) => el.classList.remove('hidden'));\n gradioApp().querySelectorAll('div .form').forEach((el) => el.classList.remove('form-compact'));\n gradioApp().querySelectorAll('.small-accordion .label-wrap').forEach((el) => el.classList.remove('accordion-compact'));\n }\n}\n\nfunction previewTheme() {\n let name = gradioApp().getElementById('setting_gradio_theme').querySelectorAll('input')?.[0].value || '';\n fetch(`${window.subpath}/file=data/themes.json`)\n .then((res) => {\n res.json()\n .then((themes) => {\n const theme = Array.isArray(themes) ? themes.find((t) => t.id === name) : null;\n if (theme) {\n window.open(theme.subdomain, '_blank');\n } else {\n const el = document.getElementById('theme-preview') as HTMLImageElement | null || createThemeElement();\n el.style.display = el.style.display === 'block' ? 'none' : 'block';\n name = name.replace('/', '-');\n el.src = `/file=ui/css/${name}.jpg`;\n }\n })\n .catch((e) => error(`previewTheme: ${e}`));\n })\n .catch((e) => error(`previewTheme: ${e}`));\n}\n\nasync function browseFolder() {\n const picker = window.showDirectoryPicker?.();\n if (!picker) return null;\n const f = await picker;\n if (f && f.kind === 'directory') return f.name;\n return null;\n}\n\nlet kanvasNotifyTimer: ReturnType | undefined;\n// Notify kanvas to resize its stage when the resize-panel width/height change. Wired through gradio's\n// .change so it also fires on programmatic updates (detect-size, paste params, swap, send-to) that the\n// client-side resolutionLock input listeners never see. Writes nothing back, so it cannot loop.\nexport function notifyKanvasResize(width: number, height: number) {\n if (window.resizeStage) {\n const w = Number(width);\n const h = Number(height);\n clearTimeout(kanvasNotifyTimer);\n kanvasNotifyTimer = setTimeout(() => window.resizeStage?.(w, h), 250);\n }\n}\n\nexport async function reconnectUI() {\n const t0 = performance.now();\n const gallery = gradioApp().getElementById('txt2img_gallery');\n const task_id = localStorage.getItem('task');\n const api_logo = Array.from(gradioApp().querySelectorAll('img')).filter((el) => el.src.endsWith('api-logo.svg'));\n if (api_logo.length > 0) api_logo[0].remove();\n if (task_id) {\n debug('task check:', task_id);\n requestProgress(task_id, null, gallery, null, null, true);\n }\n uiLoaded = true;\n\n const sd_model = gradioApp().getElementById('setting_sd_model_checkpoint');\n let loadingStarted = 0;\n let loadingMonitor: ReturnType | null = null;\n\n const sd_model_callback = () => {\n const loading = sd_model.querySelector('.eta-bar');\n if (!loading) {\n loadingStarted = 0;\n clearInterval(loadingMonitor);\n } else if (loadingStarted === 0) {\n loadingStarted = Date.now();\n loadingMonitor = setInterval(() => {\n const elapsed = Date.now() - loadingStarted;\n if (elapsed > 3000 && loading) loading.style.display = 'none';\n }, 5000);\n }\n };\n const sd_model_observer = new MutationObserver(sd_model_callback);\n sd_model_observer.observe(sd_model, { attributes: true, childList: true, subtree: true });\n const t1 = performance.now();\n log('reconnectUI', Math.round(t1 - t0));\n timer('reconnectUI', t1 - t0);\n}\n\nwindow.restartReload = restartReload;\nwindow.updateInput = updateInput;\nwindow.notifyKanvasResize = notifyKanvasResize;\nwindow.clip_gallery_urls = clip_gallery_urls;\nwindow.extract_image_from_gallery = extract_image_from_gallery;\nwindow.getCaptionActiveTab = getCaptionActiveTab;\nwindow.get_img2img_tab_index = get_img2img_tab_index;\nwindow.modelmerger = modelmerger;\nwindow.selected_gallery_index = selected_gallery_index;\nwindow.selected_gallery_files = selected_gallery_files;\nwindow.send_to_kanvas = send_to_kanvas;\nwindow.submit_control = submit_control;\nwindow.submit_framepack = submit_framepack;\nwindow.submit_img2img = submit_img2img;\nwindow.submit_ltx = submit_ltx;\nwindow.submit_postprocessing = submit_postprocessing;\nwindow.submit = submit_txt2img; // compatibility alias\nwindow.submit_txt2img = submit_txt2img;\nwindow.submit_video = submit_video;\nwindow.submit_video_wrapper = submit_video_wrapper;\nwindow.switch_to_txt2img = switch_to_txt2img;\nwindow.switch_to_img2img_tab = switch_to_img2img_tab;\nwindow.switch_to_img2img = switch_to_img2img;\nwindow.switch_to_inpaint = switch_to_inpaint;\nwindow.switch_to_sketch = switch_to_sketch;\nwindow.switch_to_composite = switch_to_composite;\nwindow.switch_to_extras = switch_to_extras;\nwindow.switch_to_control = switch_to_control;\nwindow.switch_to_video = switch_to_video;\nwindow.switch_to_caption = switch_to_caption;\nwindow.recalculate_prompts_txt2img = recalculate_prompts_txt2img;\nwindow.recalculate_prompts_img2img = recalculate_prompts_img2img;\nwindow.recalculate_prompts_inpaint = recalculate_prompts_inpaint;\nwindow.recalculate_prompts_control = recalculate_prompts_control;\nwindow.selectCheckpoint = selectCheckpoint;\nwindow.selectVAE = selectVAE;\nwindow.selectUNet = selectUNet;\nwindow.selectReference = selectReference;\nwindow.consumeDesiredCheckpointName = consumeDesiredCheckpointName;\nwindow.consumeDesiredVAEName = consumeDesiredVAEName;\nwindow.consumeDesiredUNetName = consumeDesiredUNetName;\nwindow.getDesiredCheckpointName = getDesiredCheckpointName;\nwindow.currentImageResolutionimg2img = currentImageResolutionimg2img;\nwindow.currentImageResolutioncontrol = currentImageResolutioncontrol;\nwindow.updateImg2imgResizeToTextAfterChangingImage = updateImg2imgResizeToTextAfterChangingImage;\nwindow.create_submit_args = create_submit_args;\nwindow.set_theme = set_theme;\n", "import { gradioApp } from './script';\nimport { updateInput } from './ui';\n\ntype AccordionElement = HTMLElement & {\n visibleCheckbox: HTMLInputElement;\n onVisibleCheckboxChange: () => void;\n onChecked: (checked: boolean) => void;\n};\n\nexport function inputAccordionChecked(id: string, checked: boolean): void {\n const accordion = gradioApp().getElementById(id);\n if (!(accordion instanceof HTMLElement)) return;\n const acc = accordion as AccordionElement;\n acc.visibleCheckbox.checked = checked;\n acc.onVisibleCheckboxChange();\n}\n\nfunction setupAccordion(accordion: Element): void {\n if (!(accordion instanceof HTMLElement)) return;\n const acc = accordion as AccordionElement;\n const labelWrap = accordion.querySelector('.label-wrap');\n const gradioCheckbox = gradioApp().querySelector(`#${accordion.id}-checkbox input`);\n const extra = gradioApp().querySelector(`#${accordion.id}-extra`);\n if (!(labelWrap instanceof HTMLElement) || !(gradioCheckbox instanceof HTMLInputElement)) return;\n const span = labelWrap.querySelector('span');\n if (!(span instanceof HTMLElement)) return;\n let linked = true;\n const isOpen = () => labelWrap.classList.contains('open');\n const observerAccordionOpen = new MutationObserver((mutations) => {\n mutations.forEach((mutationRecord) => {\n accordion.classList.toggle('input-accordion-open', isOpen());\n if (linked) {\n acc.visibleCheckbox.checked = isOpen();\n acc.onVisibleCheckboxChange();\n }\n });\n });\n observerAccordionOpen.observe(labelWrap, { attributes: true, attributeFilter: ['class'] });\n if (extra instanceof Node) labelWrap.insertBefore(extra, labelWrap.lastElementChild);\n acc.onChecked = (checked: boolean) => {\n if (isOpen() !== checked) labelWrap.click();\n };\n\n const visibleCheckbox = document.createElement('INPUT');\n visibleCheckbox.type = 'checkbox';\n visibleCheckbox.checked = isOpen();\n visibleCheckbox.id = `${accordion.id}-visible-checkbox`;\n visibleCheckbox.className = `${gradioCheckbox.className} input-accordion-checkbox`;\n span.insertBefore(visibleCheckbox, span.firstChild);\n acc.visibleCheckbox = visibleCheckbox as any;\n acc.onVisibleCheckboxChange = () => {\n if (linked && isOpen() !== visibleCheckbox.checked) labelWrap.click();\n gradioCheckbox.checked = visibleCheckbox.checked;\n updateInput(gradioCheckbox);\n };\n\n visibleCheckbox.addEventListener('click', (event) => {\n linked = false;\n event.stopPropagation();\n });\n visibleCheckbox.addEventListener('input', acc.onVisibleCheckboxChange);\n}\n\nwindow.inputAccordionChecked = inputAccordionChecked;\n\n// onUiLoaded(() => {\n// for (const accordion of gradioApp().querySelectorAll('.input-accordion')) setupAccordion(accordion);\n// });\n\nexport function initAccordions() {\n for (const accordion of gradioApp().querySelectorAll('.input-accordion')) setupAccordion(accordion);\n}\n", "/**\n * @type {?IDBDatabase}\n */\nimport { log } from './logger';\n\nlet db = null;\n\ninterface ThumbRecord {\n hash: string;\n folder?: string;\n [key: string]: unknown;\n}\n\nexport async function initIndexDB(): Promise {\n async function createDB(): Promise {\n return new Promise((resolve, reject) => {\n const request = indexedDB.open('SDNext', 2);\n request.onerror = (evt: Event) => reject(evt);\n request.onsuccess = (evt: Event) => {\n db = (evt.target as IDBOpenDBRequest).result;\n const countAll = db\n .transaction(['thumbs'], 'readwrite')\n .objectStore('thumbs')\n .count();\n countAll.onsuccess = () => log('initIndexDB', countAll.result);\n resolve();\n };\n request.onupgradeneeded = (evt: IDBVersionChangeEvent) => {\n db = (evt.target as IDBOpenDBRequest).result;\n const oldver = evt.oldVersion;\n if (oldver < 1) {\n const store = db.createObjectStore('thumbs', { keyPath: 'hash' });\n store.createIndex('hash', 'hash', { unique: true });\n }\n if (oldver < 2) {\n const existingStore = request.transaction.objectStore('thumbs');\n existingStore.createIndex('folder', 'folder', { unique: false });\n }\n resolve();\n };\n });\n }\n\n if (!db) await createDB();\n}\n\nexport function idbIsReady(): boolean {\n return db !== null;\n}\n\n/**\n * Reusable setup for handling IDB transactions.\n * @param {Object} resources - Required resources for implementation\n * @param {IDBTransaction} resources.transaction\n * @param {AbortSignal} resources.signal\n * @param {Function} resources.resolve\n * @param {Function} resources.reject\n * @param {*} resolveValue - Value to resolve the outer Promise with\n * @returns {() => void} - Function for manually aborting the transaction\n */\nfunction configureTransactionAbort({\n transaction,\n signal,\n resolve,\n reject,\n}: {\n transaction: IDBTransaction;\n signal: AbortSignal;\n resolve: (value: T) => void;\n reject: (reason?: unknown) => void;\n}, resolveValue: T): () => void {\n function abortTransaction() {\n signal.removeEventListener('abort', abortTransaction);\n transaction.abort();\n }\n signal.addEventListener('abort', abortTransaction);\n transaction.onabort = () => {\n signal.removeEventListener('abort', abortTransaction);\n reject(new DOMException(`Aborting database transaction. ${signal.reason}`, 'AbortError'));\n };\n transaction.onerror = (e) => {\n signal.removeEventListener('abort', abortTransaction);\n reject(new Error('Database transaction error.'));\n };\n transaction.oncomplete = () => {\n signal.removeEventListener('abort', abortTransaction);\n resolve(resolveValue);\n };\n return abortTransaction;\n}\n\nasync function add(record: ThumbRecord): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readwrite')\n .objectStore('thumbs')\n .add(record);\n request.onsuccess = (evt) => resolve(evt);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nasync function del(hash: string): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readwrite')\n .objectStore('thumbs')\n .delete(hash);\n request.onsuccess = (evt) => resolve(evt);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nasync function get(hash: string): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readonly')\n .objectStore('thumbs')\n .index('hash')\n .get(hash);\n request.onsuccess = () => resolve(request.result);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nasync function getKeys(hash: string): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readonly')\n .objectStore('thumbs')\n .index('hash')\n .getAllKeys();\n request.onsuccess = () => resolve(request.result);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nasync function put(record: ThumbRecord): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readwrite')\n .objectStore('thumbs')\n .put(record);\n request.onsuccess = (evt) => resolve(evt);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nexport async function idbGetAllKeys(index: string | null = null, query: IDBValidKey | IDBKeyRange | null = null): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n try {\n let request;\n const transaction = db.transaction('thumbs', 'readonly');\n transaction.onabort = (e) => reject(e);\n const store = transaction.objectStore('thumbs');\n if (index) request = store.index(index).getAllKeys(query);\n else request = store.getAllKeys(query);\n request.onsuccess = () => resolve(request.result);\n request.onerror = (e) => reject(e);\n } catch (err) {\n reject(err);\n }\n });\n}\n\n/**\n * Get the number of entries in the IndexedDB thumbnail cache.\n * @global\n * @param {IDBValidKey | IDBKeyRange | undefined} folder - If specified, get the count for this gallery folder. Otherwise get the total count.\n * @returns {Promise}\n */\nexport async function idbCount(folder?: IDBValidKey | IDBKeyRange): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n try {\n let request;\n const transaction = db.transaction('thumbs', 'readonly');\n transaction.onabort = (e) => reject(e);\n const store = transaction.objectStore('thumbs');\n if (folder) request = store.index('folder').count(folder);\n else request = store.count();\n request.onsuccess = () => resolve(request.result);\n request.onerror = (e) => reject(e);\n } catch (err) {\n reject(err);\n }\n });\n}\n\n/**\n * Cleanup function for IndexedDB thumbnail cache.\n * @global\n * @param {Set} keepSet - Set containing the hashes of the current files in the folder\n * @param {IDBValidKey | IDBKeyRange} folder - Folder name/path or range\n * @param {AbortSignal} signal - Signal from the AbortController for thumbCacheCleanup()\n */\nexport async function idbFolderCleanup(keepSet: Set, folder: IDBValidKey | IDBKeyRange, signal: AbortSignal): Promise {\n if (!db) return null;\n const existing = await idbGetAllKeys('folder', folder);\n const removals = new Set((existing ?? []).map((entry) => String(entry)).filter((entry) => !keepSet.has(entry))); // Don't need to keep full set in memory\n const totalRemovals = removals.size;\n if (signal.aborted) {\n throw new Error(`Aborting. ${String(signal.reason)}`);\n }\n return new Promise((resolve, reject) => {\n const transaction = db.transaction('thumbs', 'readwrite');\n const props = { transaction, signal, resolve, reject };\n configureTransactionAbort(props, totalRemovals);\n const store = transaction.objectStore('thumbs');\n removals.forEach((entry) => { store.delete(entry); });\n });\n}\n\nexport async function idbClearAll(signal: AbortSignal): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const transaction = db.transaction(['thumbs'], 'readwrite');\n const props = { transaction, signal, resolve, reject };\n configureTransactionAbort(props, null);\n transaction.objectStore('thumbs').clear();\n });\n}\n\nexport const idbAdd = add;\nexport const idbDel = del;\nexport const idbGet = get;\nexport const idbPut = put;\nexport const idbKeys = getKeys;\n", "import { authFetch } from './authWrap';\nimport { log, error, xhrPost } from './logger';\nimport { timer } from './timers';\n\ninterface LogLine {\n created: number;\n level: string;\n module: string;\n facility: string;\n msg: string;\n}\n\nlet logMonitorEl: HTMLElement | null = null;\nlet logMonitorStatus = true;\nlet logWarnings = 0;\nlet logErrors = 0;\nlet logConnected = false;\n\nfunction dateToStr(ts: number): string {\n const dt = new Date(1000 * ts);\n const year = dt.getFullYear();\n const mo = String(dt.getMonth() + 1).padStart(2, '0');\n const day = String(dt.getDate()).padStart(2, '0');\n const hour = String(dt.getHours()).padStart(2, '0');\n const min = String(dt.getMinutes()).padStart(2, '0');\n const sec = String(dt.getSeconds()).padStart(2, '0');\n const ms = String(dt.getMilliseconds()).padStart(3, '0');\n const s = `${year}-${mo}-${day} ${hour}:${min}:${sec}.${ms}`;\n return s;\n}\n\nfunction htmlEscape(text: string): string {\n return text.replaceAll('&', '&').replaceAll('<', '<').replaceAll('>', '>');\n}\n\nfunction parseLogLine(line: string): LogLine {\n let str = line.replaceAll('\\n', ' ').replaceAll('\\\\', '\\\\\\\\');\n const tracebackIndex = str.indexOf('Traceback');\n if (tracebackIndex !== -1) str = str.substring(0, tracebackIndex);\n const parsed = JSON.parse(str) as Partial;\n return {\n created: Number(parsed.created ?? Date.now()),\n level: String(parsed.level ?? 'INFO'),\n module: String(parsed.module ?? 'logMonitor'),\n facility: String(parsed.facility ?? 'ui'),\n msg: String(parsed.msg ?? ''),\n };\n}\n\nasync function logMonitor() {\n const addLogLine = (line: string): void => {\n if (!logMonitorEl) logMonitorEl = document.getElementById('logMonitorData');\n if (!logMonitorEl) return;\n try {\n const l = parseLogLine(line);\n const row = document.createElement('tr');\n // row.style = 'padding: 10px; margin: 0;';\n const level = ``;\n if (l.level === 'WARNING') logWarnings++;\n if (l.level === 'ERROR') logErrors++;\n const module = ``;\n const facilityText = l.facility.length > 20 ? `${l.facility.substring(0, 20)}...` : l.facility;\n const facility = l.facility !== 'sd' ? `` : '';\n row.innerHTML = `${level}${facility}${module}`;\n logMonitorEl.appendChild(row);\n } catch (err) {\n error(`logMonitor: ${String(err)}`);\n error(`logMonitor: ${line}`);\n }\n };\n\n const cleanupLog = (atBottom: boolean): void => {\n if (!logMonitorEl) return;\n while (logMonitorEl.childElementCount > 100 && logMonitorEl.firstElementChild) {\n logMonitorEl.removeChild(logMonitorEl.firstElementChild);\n }\n if (atBottom) logMonitorEl.scrollTop = logMonitorEl.scrollHeight;\n else if (logMonitorEl.parentElement) logMonitorEl.parentElement.style.cssText = 'border-bottom: 2px solid var(--highlight-color);';\n const elWarn = document.getElementById('logWarnings');\n const elErr = document.getElementById('logErrors');\n const modenUIBtn = document.getElementById('btn_console');\n if (elWarn) elWarn.innerText = String(logWarnings);\n if (elErr) elErr.innerText = String(logErrors);\n if (modenUIBtn) modenUIBtn.setAttribute('error-count', logErrors > 0 ? String(logErrors) : '');\n };\n\n const txtGallery = document.getElementById('txt2img_gallery');\n if (txtGallery) txtGallery.style.height = window.opts.logmonitor_show ? '50vh' : '55vh';\n const imgGallery = document.getElementById('img2img_gallery');\n if (imgGallery) imgGallery.style.height = window.opts.logmonitor_show ? '50vh' : '55vh';\n\n if (!window.opts.logmonitor_show) {\n Array.from(document.getElementsByClassName('log-monitor')).forEach((el) => {\n if (el instanceof HTMLElement) el.style.display = 'none';\n });\n return;\n }\n\n if (logMonitorStatus) setTimeout(logMonitor, window.opts.logmonitor_refresh_period);\n else setTimeout(logMonitor, 10 * 1000); // on failure try to reconnect every 10sec\n\n logMonitorStatus = false;\n if (!logMonitorEl) {\n logMonitorEl = document.getElementById('logMonitorData');\n if (logMonitorEl) {\n logMonitorEl.addEventListener('scroll', () => {\n const atBottom = logMonitorEl.scrollHeight <= (logMonitorEl.scrollTop + logMonitorEl.clientHeight);\n if (atBottom && logMonitorEl.parentElement) logMonitorEl.parentElement.style.cssText = '';\n });\n }\n }\n if (!logMonitorEl) return;\n const atBottom = logMonitorEl.scrollHeight <= (logMonitorEl.scrollTop + logMonitorEl.clientHeight);\n try {\n const res = await authFetch(`${window.api}/log?clear=True`);\n if (res?.ok) {\n logMonitorStatus = true;\n const lines = (await res.json()) as string[];\n if (logMonitorEl && lines?.length > 0 && logMonitorEl.parentElement?.parentElement instanceof HTMLElement) {\n logMonitorEl.parentElement.parentElement.style.display = window.opts.logmonitor_show ? 'block' : 'none';\n }\n for (const line of lines) addLogLine(line);\n if (!logConnected) {\n logConnected = true;\n xhrPost(`${window.api}/log`, { debug: 'connected' });\n }\n } else {\n logConnected = false;\n logErrors++;\n addLogLine(`{ \"created\": ${Date.now()}, \"level\":\"ERROR\", \"module\":\"logMonitor\", \"facility\":\"ui\", \"msg\":\"Failed to fetch log: ${res?.status} ${res?.statusText}\" }`);\n }\n cleanupLog(atBottom);\n } catch {\n logConnected = false;\n logErrors++;\n addLogLine(`{ \"created\": ${Date.now()}, \"level\":\"ERROR\", \"module\":\"logMonitor\", \"facility\":\"ui\", \"msg\":\"Failed to fetch log: server unreachable\" }`);\n cleanupLog(atBottom);\n }\n}\n\nexport async function initLogMonitor() {\n const el = document.getElementsByTagName('footer')[0];\n if (!el) return;\n const t0 = performance.now();\n el.classList.add('log-monitor');\n const uiDisabled = Array.isArray(window.opts.ui_disabled) ? window.opts.ui_disabled : [];\n if (uiDisabled.includes('logs')) return;\n el.innerHTML = `\n
${l.level}${l.module}${facilityText}${dateToStr(l.created)}${htmlEscape(l.msg)}
\n \n \n \n \n \n \n \n \n \n \n \n \n \n
TimeLevelModuleMessageWarnings 0Errors 0
\n `;\n el.style.display = 'none';\n authFetch(`${window.api}/start?agent=${encodeURI(navigator.userAgent)}`);\n logMonitor();\n const t1 = performance.now();\n log('initLogMonitor', { show: window.opts.logmonitor_show, time: Math.round(t1 - t0) });\n timer('initLogMonitor', t1 - t0);\n}\n", "import { authFetch } from './authWrap';\nimport { gradioApp, onAfterUiUpdate, onOptionsChanged, executeCallbacks, optionsChangedCallbacks } from './script';\nimport { log, debug, error } from './logger';\nimport { getENActiveTab } from './extraNetworks';\nimport { registerDragDrop, toggleCompact, setTheme, setFontSize, updateInput } from './ui';\nimport { timer } from './timers';\n\nlet settingsInitialized = false;\nlet opts_metadata = {};\nconst opts_tabs = {};\n\nfunction getSettingsTabs() {\n let nodes = gradioApp().querySelectorAll('#tab_settings .tabitem');\n if (!nodes || nodes.length === 0) nodes = gradioApp().querySelectorAll('.tab-content .tabitem');\n return nodes;\n}\n\nconst monitoredOpts: Record[] = [\n { sd_model_checkpoint: null },\n { sd_backend: () => gradioApp().getElementById('refresh_sd_model_checkpoint')?.click() },\n];\n\nexport function monitorOption(option, callback) {\n monitoredOpts.push({ [option]: callback });\n}\n\nconst AppyOpts = [ // monitored opts\n { compact_view: (val, old) => toggleCompact(val, old) },\n { gradio_theme: (val, old) => setTheme(val, old) },\n { font_size: (val, old) => setFontSize(val, old) },\n];\n\nasync function updateOpts(json_string) {\n const t0 = performance.now();\n const settings_data = JSON.parse(json_string);\n const new_opts = settings_data.values;\n opts_metadata = settings_data.metadata;\n\n const t1 = performance.now();\n for (const op of monitoredOpts) {\n const [key, callback] = Object.entries(op)[0];\n if (Object.hasOwn(opts, key) && opts[key] !== new_opts[key]) {\n log('updateOpt', key, opts[key], new_opts[key]);\n if (callback) callback(new_opts[key], opts[key]);\n }\n }\n\n for (const op of AppyOpts) {\n const [key, callback] = Object.entries(op)[0];\n if (callback) {\n const t3 = performance.now();\n callback(new_opts[key], opts[key]);\n const t4 = performance.now();\n if (t4 - t3 > 100) debug('AppyOptSlow', key, `time=${Math.round(t4 - t3)}`);\n }\n }\n\n window.opts = new_opts;\n Object.entries(opts_metadata as Record).forEach(([opt, meta]: [string, any]) => {\n if (!opts_tabs[meta.tab_name]) opts_tabs[meta.tab_name] = {};\n if (!opts_tabs[meta.tab_name].unsaved_keys) opts_tabs[meta.tab_name].unsaved_keys = new Set();\n if (!opts_tabs[meta.tab_name].saved_keys) opts_tabs[meta.tab_name].saved_keys = new Set();\n if (!meta.is_stored) opts_tabs[meta.tab_name].unsaved_keys.add(opt);\n else opts_tabs[meta.tab_name].saved_keys.add(opt);\n });\n const t2 = performance.now();\n log('updateOpts', `settings=${Object.keys(new_opts).length} callbacks=${Math.round(t2 - t1)} apply=${Math.round(t1 - t0)}`);\n timer('updateOpts', t2 - t0);\n}\n\nfunction showAllSettings() {\n // Try to ensure that the show all settings tab is opened by clicking on its tab button\n // const tab_dirty_indicator = gradioApp().getElementById('modification_indicator_show_all_pages');\n // if (tab_dirty_indicator && tab_dirty_indicator.nextSibling) tab_dirty_indicator.nextSibling.click();\n getSettingsTabs().forEach((elem) => {\n if (elem.id === 'settings_tab_licenses' || elem.id === 'settings_show_all_pages') return;\n elem.style.display = 'block';\n });\n}\n\nfunction markIfModified(setting_name, value) {\n if (!opts_metadata[setting_name]) return;\n const elem = gradioApp().getElementById(`modification_indicator_${setting_name}`);\n if (!elem) return;\n const previous_value = JSON.stringify(opts[setting_name]);\n const current_value = JSON.stringify(value);\n const changed_value = previous_value !== current_value;\n if (changed_value) elem.title = `click to revert to previous value: ${previous_value}`;\n const { is_stored } = opts_metadata[setting_name];\n if (is_stored) elem.title = 'custom value';\n elem.disabled = !changed_value && !is_stored;\n elem.classList.toggle('changed', changed_value);\n elem.classList.toggle('saved', is_stored);\n\n const { tab_name } = opts_metadata[setting_name];\n if (!opts_tabs[tab_name].changed) opts_tabs[tab_name].changed = new Set();\n const changed_items = opts_tabs[tab_name].changed;\n if (changed_value) changed_items.add(setting_name);\n else changed_items.delete(setting_name);\n const unsaved = opts_tabs[tab_name].unsaved_keys;\n const saved = opts_tabs[tab_name].saved_keys;\n\n // Set the indicator on the tab nav element\n const tab_nav_indicator = gradioApp().getElementById(`modification_indicator_${tab_name}`);\n tab_nav_indicator.disabled = (changed_items.size === 0) && (unsaved.size === 0);\n tab_nav_indicator.title = '';\n tab_nav_indicator.classList.toggle('changed', changed_items.size > 0);\n tab_nav_indicator.classList.toggle('saved', saved.size > 0);\n if (changed_items.size > 0) tab_nav_indicator.title += `click to reset ${changed_items.size} unapplied changes in this tab\\n`;\n if (saved.size > 0) tab_nav_indicator.title += `${saved.size} custom values\\n${unsaved.size} default values`;\n // TODO why is scroll happening on every change if all pages are visible?\n // elem.scrollIntoView({ behavior: 'smooth', block: 'center' });\n}\nwindow.markIfModified = markIfModified;\n\nfunction updateAllOpts() {\n if (Object.keys(opts).length !== 0) return false;\n const json_elem = gradioApp().getElementById('settings_json');\n log('updateAllOpts', !!json_elem);\n if (!json_elem) return false;\n json_elem.parentElement.style.display = 'none';\n const textarea = json_elem.querySelector('textarea');\n const jsdata = textarea.value;\n updateOpts(jsdata);\n return true;\n}\n\nasync function onAfterUiUpdateCallback() {\n if (!updateAllOpts()) return;\n const json_elem = gradioApp().getElementById('settings_json');\n const textarea = json_elem.querySelector('textarea');\n executeCallbacks(optionsChangedCallbacks);\n registerDragDrop();\n\n Object.defineProperty(textarea, 'value', {\n set(newValue) {\n const valueProp = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value');\n const oldValue = valueProp.get.call(textarea);\n valueProp.set.call(textarea, newValue);\n if (oldValue !== newValue) updateOpts(textarea.value);\n executeCallbacks(optionsChangedCallbacks);\n },\n get() {\n const valueProp = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value');\n return valueProp.get.call(textarea);\n },\n });\n\n const settingsSearch = gradioApp().querySelectorAll('#settings_search > label > textarea')[0];\n let settingsTimer: ReturnType | undefined;\n let settingSearchValue = '';\n\n function doSettingsSearch() {\n if (settingSearchValue === settingsSearch.value.trim().toLowerCase()) return;\n showAllSettings();\n const value = settingsSearch.value.trim().toLowerCase();\n log('doSettingsSearch', value);\n settingSearchValue = value;\n getSettingsTabs().forEach((section) => {\n section.querySelectorAll('.dirtyable').forEach((setting) => {\n const visible = setting.innerText.toLowerCase().includes(value) || setting.id.toLowerCase().includes(value);\n const parent = setting.closest('.settings_section');\n if (!visible) parent.style.display = 'none';\n else parent.style.removeProperty('display');\n });\n });\n }\n\n settingsSearch.oninput = (e) => {\n if (settingsTimer) clearTimeout(settingsTimer);\n settingsTimer = setTimeout(doSettingsSearch, 250);\n };\n settingsSearch.onkeypress = (e) => {\n if (e.key === 'Enter') {\n if (settingsTimer) clearTimeout(settingsTimer);\n doSettingsSearch();\n }\n };\n}\n\nonAfterUiUpdate(onAfterUiUpdateCallback);\n\nasync function onOptionsChangedCallback() {\n const setting_elems = gradioApp().querySelectorAll('#settings [id^=\"setting_\"]');\n setting_elems.forEach((elem) => {\n const setting_name = elem.id.replace('setting_', '');\n markIfModified(setting_name, opts[setting_name]);\n });\n}\n\nonOptionsChanged(onOptionsChangedCallback);\n\nexport async function initModels() {\n const warn = () => `\n

No models available

\n - Select a model from reference list to download or
\n - Set model path to a folder containing your models
\n Current model path: ${opts.ckpt_dir}
\n `;\n const el = gradioApp().getElementById('main_info');\n const en = gradioApp().getElementById('txt2img_extra_networks');\n if (!el || !en) return;\n const req = await authFetch(`${window.api}/sd-models`);\n const res = req.ok ? await req.json() : [];\n log('initModels', res.length);\n const ready = () => `\n

Ready

\n ${res.length} models available
\n `;\n el.innerHTML = res.length > 0 ? ready() : warn();\n el.style.display = 'block';\n setTimeout(() => { el.style.display = 'none'; }, res.length === 0 ? 30000 : 1500);\n if (res.length === 0) {\n if (en.classList.contains('hide')) gradioApp().getElementById('txt2img_extra_networks_btn').click();\n const repeat = setInterval(() => {\n const buttons = Array.from(gradioApp().querySelectorAll('#txt2img_model_subdirs > button')) || [];\n const reference = buttons.find((b) => (b.innerText === 'Reference') || (b.innerText === 'Distilled') || (b.innerText === 'Community') || (b.innerText === 'Quantized') || (b.innerText === 'Cloud'));\n if (reference) {\n clearInterval(repeat);\n reference.click();\n log('enReferenceSelect');\n }\n }, 100);\n }\n}\n\nexport async function initSettings() {\n if (settingsInitialized) return;\n const t0 = performance.now();\n settingsInitialized = true;\n const tabNavElements = gradioApp().querySelector('#settings > .tab-nav');\n if (!tabNavElements) {\n error('initSettings', 'No tab nav elements found');\n return;\n }\n const tabNavButtons = gradioApp().querySelectorAll('#settings > .tab-nav > button');\n const tabElements = gradioApp().querySelectorAll('#settings > div:not(.tab-nav)');\n const observer = new MutationObserver((mutations) => {\n const showAllPages = gradioApp().getElementById('settings_show_all_pages');\n if (showAllPages.style.display === 'none') return;\n const mutation = (mut) => mut.type === 'attributes' && mut.attributeName === 'style';\n if (mutations.some(mutation)) showAllSettings();\n });\n const tabContentWrapper = document.createElement('div');\n tabContentWrapper.className = 'tab-content';\n tabNavElements.parentElement.insertBefore(tabContentWrapper, tabNavElements.nextSibling);\n tabElements.forEach((elem, index) => {\n const tabName = elem.id.replace('settings_section_tab_', '');\n const indicator = gradioApp().getElementById(`modification_indicator_${tabName}`);\n if (indicator) {\n tabNavElements.insertBefore(document.createElement('br'), tabNavButtons[index]);\n tabNavElements.insertBefore(indicator, tabNavButtons[index]);\n }\n tabContentWrapper.appendChild(elem);\n observer.observe(elem, { attributes: true, attributeFilter: ['style'] });\n });\n const t1 = performance.now();\n log('initSettings', Math.round(t1 - t0));\n timer('initSettings', t1 - t0);\n}\n", "import { debug, log } from './logger';\nimport { authFetch } from './authWrap';\nimport { monitorOption } from './settings';\n\ninterface VersionInfo {\n updated?: string;\n commit?: string;\n branch?: string;\n model?: string;\n}\n\nlet monitorActive = false;\n\nexport class ConnectionMonitorState {\n static ws: WebSocket | undefined;\n static url = '';\n static delay = 1000;\n static element: HTMLElement | undefined;\n static version = '';\n static commit = '';\n static branch = '';\n static model = '';\n static startup: Date = new Date();\n static online = false;\n static ts: Date = new Date();\n\n static getModel(): string {\n const cp = window.opts?.sd_model_checkpoint || '';\n return cp ? this.trimModelName(cp) : 'unknown model';\n }\n\n static trimModelName(name: string): string {\n return name.replace(/\\s*\\[.*\\]\\s*$/, '').split(/[\\\\/]/).pop().trim() || 'unknown model';\n }\n\n static setData({ online, data }: { online: boolean; data: VersionInfo }) {\n if (online !== this.online) {\n this.online = online;\n this.ts = new Date();\n debug('monitorState', { online: ConnectionMonitorState.online, ts: ConnectionMonitorState.ts });\n }\n if (data?.updated) this.version = data.updated;\n if (data?.commit) this.commit = data.commit;\n if (data?.branch) this.branch = data.branch;\n if (data?.model) this.model = this.trimModelName(data.model);\n }\n\n static toHTML(): string {\n if (!this.model) this.model = this.getModel();\n return `\n Version: ${this.version}
\n Commit: ${this.commit}
\n Branch: ${this.branch}
\n Status: ${this.online ? 'online' : 'offline'}
\n Model: ${this.model}
\n Since: ${this.startup.toLocaleString()}
\n `;\n }\n\n static updateState() {\n if (!this.element) {\n const el = document.getElementById('logo_nav');\n if (el) this.element = el;\n else return;\n }\n this.element.dataset.hint = this.toHTML();\n this.element.style.backgroundColor = this.online ? 'var(--sd-main-accent-color)' : 'var(--color-error)';\n }\n}\n\nasync function updateIndicator(online: boolean, data: VersionInfo = {}, msg?: string): Promise {\n ConnectionMonitorState.setData({ online, data });\n ConnectionMonitorState.updateState();\n if (msg) log('monitorConnection:', { online, data, msg });\n}\n\nasync function wsMonitorLoop() {\n const delayed = Date.now() - ConnectionMonitorState.ts.getTime();\n if ((delayed > 60 * 60) && (ConnectionMonitorState.delay < 10) && !ConnectionMonitorState.online) ConnectionMonitorState.delay = 10000;\n else if ((delayed > 5 * 60) && (ConnectionMonitorState.delay < 5) && !ConnectionMonitorState.online) ConnectionMonitorState.delay = 5000;\n else ConnectionMonitorState.delay = 2000;\n try {\n ConnectionMonitorState.ws = new WebSocket(`${ConnectionMonitorState.url}/queue/join`);\n ConnectionMonitorState.ws.onopen = () => {};\n ConnectionMonitorState.ws.onmessage = () => updateIndicator(true);\n ConnectionMonitorState.ws.onclose = () => setTimeout(wsMonitorLoop, ConnectionMonitorState.delay); // main re-check loop\n ConnectionMonitorState.ws.onerror = (e: Event) => updateIndicator(false, {}, String((e as ErrorEvent).message || 'unknown error')); // actual error\n } catch (e) {\n updateIndicator(false, {}, String((e as Error).message || e));\n // eslint-disable-next-line @typescript-eslint/no-use-before-define\n setTimeout(monitorConnection, ConnectionMonitorState.delay);\n }\n}\n\nexport async function monitorConnection() {\n if (!monitorActive) { // start monitor loop only once on startup\n monitorActive = true;\n monitorOption('sd_model_checkpoint', (newVal) => { // runs before opt actually changes\n ConnectionMonitorState.model = newVal;\n ConnectionMonitorState.updateState();\n });\n }\n ConnectionMonitorState.startup = new Date();\n\n let data: VersionInfo = {};\n try {\n const res = await authFetch(`${window.api}/version`);\n if (!res) throw new Error('No response');\n data = await res.json();\n log('monitorConnection:', { data });\n ConnectionMonitorState.startup = new Date();\n ConnectionMonitorState.url = res.url.split('/sdapi')[0].replace('https:', 'wss:').replace('http:', 'ws:'); // update global url as ws need fqdn\n updateIndicator(true, data);\n wsMonitorLoop();\n } catch {\n updateIndicator(false, data);\n setTimeout(monitorConnection, ConnectionMonitorState.delay);\n }\n}\n", "// Stable Diffusion WebUI - Bracket checker\n// By Hingashi no Florin/Bwin4L & @akx\n// Counts open and closed brackets (round, square, curly) in the prompt and negative prompt text boxes in the txt2img and img2img tabs.\n// If there's a mismatch, the keyword counter turns red and if you hover on it, a tooltip tells you what's wrong.\n\nimport { gradioApp } from './script';\nimport { log } from './logger';\nimport { timer } from './timers';\n\nfunction checkBrackets(textArea: HTMLTextAreaElement, counterElt: HTMLElement): void {\n const counts: Record = {};\n const errors: string[] = [];\n\n function checkPair(open: string, close: string, kind: string): void {\n if (counts[open] !== counts[close]) errors.push(`${open}...${close} - Detected ${counts[open] || 0} opening and ${counts[close] || 0} closing ${kind}.`);\n }\n\n (textArea.value.match(/[(){}[\\]]/g) || []).forEach((bracket) => { counts[bracket] = (counts[bracket] || 0) + 1; });\n checkPair('(', ')', 'round brackets');\n checkPair('[', ']', 'square brackets');\n checkPair('{', '}', 'curly brackets');\n counterElt.title = errors.join('\\n');\n counterElt.classList.toggle('error', errors.length !== 0);\n}\n\nfunction setupBracketChecking(idPrompt: string, idCounter: string): void {\n const textarea = gradioApp().querySelector(`#${idPrompt} > label > textarea`);\n const counter = gradioApp().getElementById(idCounter);\n if (!(textarea instanceof HTMLTextAreaElement) || !counter) return;\n textarea.addEventListener('input', () => checkBrackets(textarea, counter));\n}\n\nexport async function initPromptChecker() {\n const t0 = performance.now();\n setupBracketChecking('txt2img_prompt', 'txt2img_token_counter');\n setupBracketChecking('txt2img_neg_prompt', 'txt2img_negative_token_counter');\n setupBracketChecking('img2img_prompt', 'img2img_token_counter');\n setupBracketChecking('img2img_neg_prompt', 'img2img_negative_token_counter');\n setupBracketChecking('control_prompt', 'control_token_counter');\n setupBracketChecking('control_neg_prompt', 'control_negative_token_counter');\n setupBracketChecking('video_prompt', 'video_token_counter');\n setupBracketChecking('video_neg_prompt', 'video_negative_token_counter');\n const t1 = performance.now();\n log('initPromptChecker', Math.round(t1 - t0));\n timer('initPromptChecker', t1 - t0);\n}\n", "// @ts-nocheck\n\n// SHA-256 (+ HMAC and PBKDF2) for JavaScript.\n//\n// Written in 2014-2016 by Dmitry Chestnykh.\n// Public domain, no warranty.\n//\n// Functions (accept and return Uint8Arrays):\n//\n// sha256(message) -> hash\n// sha256.hmac(key, message) -> mac\n// sha256.pbkdf2(password, salt, rounds, dkLen) -> dk\n//\n// Classes:\n//\n// new sha256.Hash()\n// new sha256.HMAC(key)\n//\n\n\nconst digestLength = 32;\nconst blockSize = 64;\n\n// SHA-256 constants\n\nconst K = new Uint32Array([\n 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,\n 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,\n 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,\n 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,\n 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,\n 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,\n 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,\n 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,\n 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,\n 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,\n]);\nfunction hashBlocks(w, v, p, pos, len) {\n let a; let b; let c; let d; let e; let f; let g; let h; let u; let i; let j; let t1; let\n t2;\n while (len >= 64) {\n a = v[0];\n b = v[1];\n c = v[2];\n d = v[3];\n e = v[4];\n f = v[5];\n g = v[6];\n h = v[7];\n for (i = 0; i < 16; i++) {\n j = pos + i * 4;\n w[i] = (((p[j] & 0xff) << 24) | ((p[j + 1] & 0xff) << 16)\n | ((p[j + 2] & 0xff) << 8) | (p[j + 3] & 0xff));\n }\n for (i = 16; i < 64; i++) {\n u = w[i - 2];\n t1 = (u >>> 17 | u << (32 - 17)) ^ (u >>> 19 | u << (32 - 19)) ^ (u >>> 10);\n u = w[i - 15];\n t2 = (u >>> 7 | u << (32 - 7)) ^ (u >>> 18 | u << (32 - 18)) ^ (u >>> 3);\n w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);\n }\n for (i = 0; i < 64; i++) {\n t1 = (((((e >>> 6 | e << (32 - 6)) ^ (e >>> 11 | e << (32 - 11))\n ^ (e >>> 25 | e << (32 - 25))) + ((e & f) ^ (~e & g))) | 0)\n + ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;\n t2 = (((a >>> 2 | a << (32 - 2)) ^ (a >>> 13 | a << (32 - 13))\n ^ (a >>> 22 | a << (32 - 22))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;\n h = g;\n g = f;\n f = e;\n e = (d + t1) | 0;\n d = c;\n c = b;\n b = a;\n a = (t1 + t2) | 0;\n }\n v[0] += a;\n v[1] += b;\n v[2] += c;\n v[3] += d;\n v[4] += e;\n v[5] += f;\n v[6] += g;\n v[7] += h;\n pos += 64;\n len -= 64;\n }\n return pos;\n}\n// Hash implements SHA256 hash algorithm.\nconst Hash = /** @class */ (function () {\n function Hash() {\n this.digestLength = digestLength;\n this.blockSize = blockSize;\n // Note: Int32Array is used instead of Uint32Array for performance reasons.\n this.state = new Int32Array(8); // hash state\n this.temp = new Int32Array(64); // temporary state\n this.buffer = new Uint8Array(128); // buffer for data to hash\n this.bufferLength = 0; // number of bytes in buffer\n this.bytesHashed = 0; // number of total bytes hashed\n this.finished = false; // indicates whether the hash was finalized\n this.reset();\n }\n // Resets hash state making it possible\n // to reuse this instance to hash other data.\n Hash.prototype.reset = function () {\n this.state[0] = 0x6a09e667;\n this.state[1] = 0xbb67ae85;\n this.state[2] = 0x3c6ef372;\n this.state[3] = 0xa54ff53a;\n this.state[4] = 0x510e527f;\n this.state[5] = 0x9b05688c;\n this.state[6] = 0x1f83d9ab;\n this.state[7] = 0x5be0cd19;\n this.bufferLength = 0;\n this.bytesHashed = 0;\n this.finished = false;\n return this;\n };\n // Cleans internal buffers and re-initializes hash state.\n Hash.prototype.clean = function () {\n for (var i = 0; i < this.buffer.length; i++) {\n this.buffer[i] = 0;\n }\n for (var i = 0; i < this.temp.length; i++) {\n this.temp[i] = 0;\n }\n this.reset();\n };\n // Updates hash state with the given data.\n //\n // Optionally, length of the data can be specified to hash\n // fewer bytes than data.length.\n //\n // Throws error when trying to update already finalized hash:\n // instance must be reset to use it again.\n Hash.prototype.update = function (data, dataLength) {\n if (dataLength === void 0) { dataLength = data.length; }\n if (this.finished) {\n throw new Error(\"SHA256: can't update because hash was finished.\");\n }\n let dataPos = 0;\n this.bytesHashed += dataLength;\n if (this.bufferLength > 0) {\n while (this.bufferLength < 64 && dataLength > 0) {\n this.buffer[this.bufferLength++] = data[dataPos++];\n dataLength--;\n }\n if (this.bufferLength === 64) {\n hashBlocks(this.temp, this.state, this.buffer, 0, 64);\n this.bufferLength = 0;\n }\n }\n if (dataLength >= 64) {\n dataPos = hashBlocks(this.temp, this.state, data, dataPos, dataLength);\n dataLength %= 64;\n }\n while (dataLength > 0) {\n this.buffer[this.bufferLength++] = data[dataPos++];\n dataLength--;\n }\n return this;\n };\n // Finalizes hash state and puts hash into out.\n //\n // If hash was already finalized, puts the same value.\n Hash.prototype.finish = function (out) {\n if (!this.finished) {\n const bytesHashed = this.bytesHashed;\n const left = this.bufferLength;\n const bitLenHi = (bytesHashed / 0x20000000) | 0;\n const bitLenLo = bytesHashed << 3;\n const padLength = (bytesHashed % 64 < 56) ? 64 : 128;\n this.buffer[left] = 0x80;\n for (let i = left + 1; i < padLength - 8; i++) {\n this.buffer[i] = 0;\n }\n this.buffer[padLength - 8] = (bitLenHi >>> 24) & 0xff;\n this.buffer[padLength - 7] = (bitLenHi >>> 16) & 0xff;\n this.buffer[padLength - 6] = (bitLenHi >>> 8) & 0xff;\n this.buffer[padLength - 5] = (bitLenHi >>> 0) & 0xff;\n this.buffer[padLength - 4] = (bitLenLo >>> 24) & 0xff;\n this.buffer[padLength - 3] = (bitLenLo >>> 16) & 0xff;\n this.buffer[padLength - 2] = (bitLenLo >>> 8) & 0xff;\n this.buffer[padLength - 1] = (bitLenLo >>> 0) & 0xff;\n hashBlocks(this.temp, this.state, this.buffer, 0, padLength);\n this.finished = true;\n }\n for (let i = 0; i < 8; i++) {\n out[i * 4 + 0] = (this.state[i] >>> 24) & 0xff;\n out[i * 4 + 1] = (this.state[i] >>> 16) & 0xff;\n out[i * 4 + 2] = (this.state[i] >>> 8) & 0xff;\n out[i * 4 + 3] = (this.state[i] >>> 0) & 0xff;\n }\n return this;\n };\n // Returns the final hash digest.\n Hash.prototype.digest = function () {\n const out = new Uint8Array(this.digestLength);\n this.finish(out);\n return out;\n };\n // Internal function for use in HMAC for optimization.\n Hash.prototype._saveState = function (out) {\n for (let i = 0; i < this.state.length; i++) {\n out[i] = this.state[i];\n }\n };\n // Internal function for use in HMAC for optimization.\n Hash.prototype._restoreState = function (from, bytesHashed) {\n for (let i = 0; i < this.state.length; i++) {\n this.state[i] = from[i];\n }\n this.bytesHashed = bytesHashed;\n this.finished = false;\n this.bufferLength = 0;\n };\n return Hash;\n}());\nwindow.Hash = Hash;\n// HMAC implements HMAC-SHA256 message authentication algorithm.\nconst HMAC = /** @class */ (function () {\n function HMAC(key) {\n this.inner = new Hash();\n this.outer = new Hash();\n this.blockSize = this.inner.blockSize;\n this.digestLength = this.inner.digestLength;\n const pad = new Uint8Array(this.blockSize);\n if (key.length > this.blockSize) {\n (new Hash()).update(key).finish(pad).clean();\n } else {\n for (let i = 0; i < key.length; i++) {\n pad[i] = key[i];\n }\n }\n for (let i = 0; i < pad.length; i++) {\n pad[i] ^= 0x36;\n }\n this.inner.update(pad);\n for (let i = 0; i < pad.length; i++) {\n pad[i] ^= 0x36 ^ 0x5c;\n }\n this.outer.update(pad);\n this.istate = new Uint32Array(8);\n this.ostate = new Uint32Array(8);\n this.inner._saveState(this.istate);\n this.outer._saveState(this.ostate);\n for (let i = 0; i < pad.length; i++) {\n pad[i] = 0;\n }\n }\n // Returns HMAC state to the state initialized with key\n // to make it possible to run HMAC over the other data with the same\n // key without creating a new instance.\n HMAC.prototype.reset = function () {\n this.inner._restoreState(this.istate, this.inner.blockSize);\n this.outer._restoreState(this.ostate, this.outer.blockSize);\n return this;\n };\n // Cleans HMAC state.\n HMAC.prototype.clean = function () {\n for (let i = 0; i < this.istate.length; i++) {\n this.ostate[i] = this.istate[i] = 0;\n }\n this.inner.clean();\n this.outer.clean();\n };\n // Updates state with provided data.\n HMAC.prototype.update = function (data) {\n this.inner.update(data);\n return this;\n };\n // Finalizes HMAC and puts the result in out.\n HMAC.prototype.finish = function (out) {\n if (this.outer.finished) {\n this.outer.finish(out);\n } else {\n this.inner.finish(out);\n this.outer.update(out, this.digestLength).finish(out);\n }\n return this;\n };\n // Returns message authentication code.\n HMAC.prototype.digest = function () {\n const out = new Uint8Array(this.digestLength);\n this.finish(out);\n return out;\n };\n return HMAC;\n}());\nwindow.HMAC = HMAC;\n// Returns SHA256 hash of data.\nfunction hash(data) {\n const h = (new Hash()).update(data);\n const digest = h.digest();\n h.clean();\n return digest;\n}\nwindow.hash = hash;\n// Function hash is both available as module.hash and as default export.\n// Returns HMAC-SHA256 of data under the key.\nfunction hmac(key, data) {\n const h = (new HMAC(key)).update(data);\n const digest = h.digest();\n h.clean();\n return digest;\n}\nwindow.hmac = hmac;\n// Fills hkdf buffer like this:\n// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01)\nfunction fillBuffer(buffer, hmac, info, counter) {\n // Counter is a byte value: check if it overflowed.\n const num = counter[0];\n if (num === 0) {\n throw new Error('hkdf: cannot expand more');\n }\n // Prepare HMAC instance for new data with old key.\n hmac.reset();\n // Hash in previous output if it was generated\n // (i.e. counter is greater than 1).\n if (num > 1) {\n hmac.update(buffer);\n }\n // Hash in info if it exists.\n if (info) {\n hmac.update(info);\n }\n // Hash in the counter.\n hmac.update(counter);\n // Output result to buffer and clean HMAC instance.\n hmac.finish(buffer);\n // Increment counter inside typed array, this works properly.\n counter[0]++;\n}\nconst hkdfSalt = new Uint8Array(digestLength); // Filled with zeroes.\nfunction hkdf(key, salt, info, length) {\n if (salt === void 0) { salt = hkdfSalt; }\n if (length === void 0) { length = 32; }\n const counter = new Uint8Array([1]);\n // HKDF-Extract uses salt as HMAC key, and key as data.\n const okm = hmac(salt, key);\n // Initialize HMAC for expanding with extracted key.\n // Ensure no collisions with `hmac` function.\n const hmac_ = new HMAC(okm);\n // Allocate buffer.\n const buffer = new Uint8Array(hmac_.digestLength);\n let bufpos = buffer.length;\n const out = new Uint8Array(length);\n for (let i = 0; i < length; i++) {\n if (bufpos === buffer.length) {\n fillBuffer(buffer, hmac_, info, counter);\n bufpos = 0;\n }\n out[i] = buffer[bufpos++];\n }\n hmac_.clean();\n buffer.fill(0);\n counter.fill(0);\n return out;\n}\nwindow.hkdf = hkdf;\n// Derives a key from password and salt using PBKDF2-HMAC-SHA256\n// with the given number of iterations.\n//\n// The number of bytes returned is equal to dkLen.\n//\n// (For better security, avoid dkLen greater than hash length - 32 bytes).\nfunction pbkdf2(password, salt, iterations, dkLen) {\n const prf = new HMAC(password);\n const len = prf.digestLength;\n const ctr = new Uint8Array(4);\n const t = new Uint8Array(len);\n const u = new Uint8Array(len);\n const dk = new Uint8Array(dkLen);\n for (var i = 0; i * len < dkLen; i++) {\n const c = i + 1;\n ctr[0] = (c >>> 24) & 0xff;\n ctr[1] = (c >>> 16) & 0xff;\n ctr[2] = (c >>> 8) & 0xff;\n ctr[3] = (c >>> 0) & 0xff;\n prf.reset();\n prf.update(salt);\n prf.update(ctr);\n prf.finish(u);\n for (var j = 0; j < len; j++) {\n t[j] = u[j];\n }\n for (var j = 2; j <= iterations; j++) {\n prf.reset();\n prf.update(u).finish(u);\n for (let k = 0; k < len; k++) {\n t[k] ^= u[k];\n }\n }\n for (var j = 0; j < len && i * len + j < dkLen; j++) {\n dk[i * len + j] = t[j];\n }\n }\n for (var i = 0; i < len; i++) {\n t[i] = u[i] = 0;\n }\n for (var i = 0; i < 4; i++) {\n ctr[i] = 0;\n }\n prf.clean();\n return dk;\n}\nwindow.pbkdf2 = pbkdf2;\n", "/* eslint-disable max-classes-per-file, @typescript-eslint/no-use-before-define */\nimport './js/sha256';\nimport { log, debug, error } from './logger';\nimport { authFetch } from './authWrap';\nimport { gradioApp, onAfterUiUpdate } from './script';\nimport { timer } from './timers';\nimport { monitorOption } from './settings';\n\nimport {\n idbAdd,\n idbCount,\n idbFolderCleanup,\n idbClearAll,\n idbGet,\n idbKeys,\n idbIsReady,\n} from './indexdb';\n\nlet ws;\nlet url;\nlet currentSize = 0;\nlet currentSort = 'none';\nlet currentName = '';\nlet currentImage = null;\nlet currentTitle = '';\nlet currentGalleryFolder = null;\nlet pruneImagesTimer;\nlet outstanding = 0;\nlet gallerySelection = { files: [], index: -1 };\nlet maintenanceController = new AbortController();\nconst maxFetchRequests = 32;\nconst fragmentSize = 100;\nconst minCleanupCount = 1000;\nconst minCleanupTime = 1000 * 60 * 60; // 1 hour\nconst folderStylesheet = new CSSStyleSheet();\nconst fileStylesheet = new CSSStyleSheet();\nconst iconStopwatch = String.fromCodePoint(9201);\n// Store separator states for the session\nconst separatorStates = new Map();\nconst el = {\n folders: undefined,\n files: undefined,\n search: undefined,\n status: undefined,\n btnSend: undefined,\n overlay: undefined,\n size: undefined,\n};\nconst cleanupTimers = {};\nconst maintenanceTimers = {};\nconst fetchQueue = [];\n\nconst SUPPORTED_EXTENSIONS = ['jpg', 'jpeg', 'png', 'webp', 'tiff', 'jp2', 'jxl', 'gif', 'mp4', 'mkv', 'avi', 'mjpeg', 'mpg', 'avr'];\n\nconst gallerySorter = {\n nameA: { name: 'Name Ascending', func: (a, b) => a.name.localeCompare(b.name) },\n nameD: { name: 'Name Descending', func: (b, a) => a.name.localeCompare(b.name) },\n sizeD: { name: 'Size Ascending', func: (a, b) => a.size - b.size },\n sizeA: { name: 'Size Descending', func: (b, a) => a.size - b.size },\n resD: { name: 'Resolution Ascending', func: (a, b) => a.width * a.height - b.width * b.height },\n resA: { name: 'Resolution Descending', func: (b, a) => a.width * a.height - b.width * b.height },\n modD: { name: 'Modified Ascending', func: (a, b) => a.mtime - b.mtime },\n modA: { name: 'Modified Descending', func: (b, a) => a.mtime - b.mtime },\n none: { name: 'None', func: undefined },\n};\n\nlet sortMode = gallerySorter.none;\n\nasync function getHash(str) {\n let hex = '';\n const strBuf = new TextEncoder().encode(str);\n let hashBuf;\n if (crypto?.subtle?.digest) {\n hashBuf = await crypto.subtle.digest('SHA-256', strBuf);\n } else {\n const hashResult: any = hash(strBuf);\n hashBuf = hashResult.buffer; // from sha256.js\n }\n const view = new DataView(hashBuf);\n for (let i = 0; i < hashBuf.byteLength; i += 4) hex += (`00000000${view.getUint32(i).toString(16)}`).slice(-8);\n return hex;\n}\n\nfunction getVisibleGalleryFiles() {\n if (!el.files) return [];\n return Array.from(el.files.children).filter((node) => node.name && node.offsetParent);\n}\n\nfunction updateGallerySelectionClasses(files = gallerySelection.files, index = gallerySelection.index) {\n files.forEach((file, i) => {\n file.classList.toggle('gallery-file-selected', i === index);\n });\n}\n\nfunction refreshGallerySelection() {\n updateGallerySelectionClasses(gallerySelection.files, -1);\n const files = getVisibleGalleryFiles();\n const index = files.findIndex((file) => file.src === currentImage);\n gallerySelection = { files, index };\n updateGallerySelectionClasses(files, index);\n}\n\nfunction resetGallerySelection() {\n updateGallerySelectionClasses(gallerySelection.files, -1);\n gallerySelection = { files: [], index: -1 };\n currentImage = null;\n currentName = '';\n currentTitle = '';\n}\n\nfunction applyGallerySelection(index, { send = true } = {}) {\n if (!gallerySelection.files.length) refreshGallerySelection();\n const { files } = gallerySelection;\n if (!files.length) return;\n if (!Number.isInteger(index) || index < 0 || index >= files.length) {\n log('gallery selection index out of range', index, files.length);\n resetGallerySelection();\n return;\n }\n gallerySelection.index = index;\n currentImage = files[index].src;\n currentName = files[index].name;\n currentTitle = files[index].title;\n updateGallerySelectionClasses(files, index);\n if (send && el.btnSend) el.btnSend.click();\n}\n\nfunction setGallerySelectionByElement(element, options) {\n if (!gallerySelection.files.length) refreshGallerySelection();\n let index = gallerySelection.files.findIndex((file) => file === element);\n if (index < 0) {\n refreshGallerySelection();\n index = gallerySelection.files.findIndex((file) => file === element);\n }\n if (index >= 0) applyGallerySelection(index, options);\n}\n\nfunction buildGalleryFileUrl(path) {\n return new URL(`/file=${encodeURI(path)}`, window.location.origin).toString();\n}\n\nwindow.getGallerySelection = () => ({ index: gallerySelection.index, files: gallerySelection.files });\nwindow.setGallerySelection = (index, options) => applyGallerySelection(index, options);\nwindow.getGallerySelectedUrl = () => (currentImage ? buildGalleryFileUrl(currentImage) : null);\n\n/**\n * Wait for gallery to finish populating\n * @param {number} expectedSize - Expected gallery size\n * @param {AbortSignal} signal - AbortController signal\n */\nasync function awaitForGallery(expectedSize, signal) {\n while (Math.max(galleryHashes.size, galleryHashes.fallback) < expectedSize && !signal.aborted) await new Promise((resolve) => { setTimeout(resolve, 500); }); // longer interval because it's a low priority check\n signal.throwIfAborted();\n}\n\nfunction updateGalleryStyles() {\n if (opts.theme_type?.toLowerCase() === 'modern') {\n folderStylesheet.replace(`\n .gallery-folder {\n cursor: pointer;\n padding: 8px 6px 8px 6px;\n background-color: var(--sd-button-normal-color);\n border-radius: var(--sd-border-radius);\n text-align: left;\n direction: rtl; /* Used to overflow the beginning instead of the end */\n min-width: 12em;\n max-width: 100%;\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n transition-duration: 0.2s;\n transition-property: color, opacity, background-color, border-color;\n transition-timing-function: ease-out;\n }\n .gallery-folder:hover {\n background-color: var(--button-primary-background-fill-hover, var(--sd-button-hover-color));\n }\n .gallery-folder-selected {\n background-color: var(--sd-button-selected-color);\n color: var(--sd-button-selected-text-color);\n }\n .gallery-folder-icon {\n font-size: 1.2em;\n color: var(--sd-button-icon-color);\n margin-right: 1em;\n filter: drop-shadow(1px 1px 2px black);\n float: left;\n }\n `);\n } else {\n folderStylesheet.replace(`\n .gallery-folder {\n cursor: pointer;\n padding: 8px 6px 8px 6px;\n max-width: 200px;\n overflow-x: hidden;\n text-wrap: nowrap;\n text-overflow: ellipsis;\n }\n .gallery-folder:hover {\n background-color: var(--button-primary-background-fill-hover);\n }\n .gallery-folder-selected {\n background-color: var(--button-primary-background-fill);\n }\n `);\n }\n const size = el.size ? el.size.value : opts.extra_networks_card_size;\n fileStylesheet.replace(`\n .gallery-file {\n object-fit: contain;\n cursor: pointer;\n height: ${size}px;\n width: ${opts.browser_fixed_width ? `${size}px` : 'unset'};\n }\n .gallery-file:hover {\n filter: grayscale(100%);\n }\n .gallery-overlay {\n position: absolute;\n height: 24px;\n background-color: rgba(0,0,0,0.7);\n display: block;\n text-align: right;\n padding: 4px;\n font-size: 1.2em;\n letter-spacing: 0.5em;\n width: 140px;\n margin-top: calc(140px - 32px);\n opacity: 75%;\n }\n :host(.gallery-file-selected) .gallery-file {\n box-shadow: 0 0 0 2px var(--sd-button-selected-color);\n }\n `);\n}\n\n// Classes\n\nclass HashSet extends Set {\n fallback = 0;\n constructor(val?: any) {\n super(val);\n this.fallback = 0;\n }\n\n override add(value: any): this {\n ++this.fallback;\n super.add(value);\n return this;\n }\n\n override clear(): void {\n this.fallback = 0;\n super.clear();\n }\n}\n\nconst galleryHashes = new HashSet();\n\nclass SimpleProgressBar {\n #container = document.createElement('div');\n #progress = document.createElement('div');\n #textDiv = document.createElement('div');\n #text = document.createElement('span');\n #visible = false;\n #interval: ReturnType | undefined;\n #max = 0;\n defaultStats = { queue: 0, fetch: 0, hash: 0, db: 0, cached: 0, fetched: 0, failed: 0, error: 0, callback: 0, elapsed: 0, count: 0 };\n stats = { ...this.defaultStats };\n /** @type {Set} */\n #monitoredSet;\n\n constructor(monitoredSet) {\n this.#monitoredSet = monitoredSet; // This is required because incrementing a variable with a class method turned out to not be an atomic operation\n this.#container.style.cssText = 'position:relative; overflow:hidden; border-radius:var(--sd-border-radius); width:100%; background-color:hsla(0,0%,36%,0.3); height:1.2rem; margin:0; padding:0; display:none;';\n this.#progress.style.cssText = 'position:absolute; left:0; height:100%; width:0; transition:width 200ms;';\n this.#progress.style.backgroundColor = 'var(--sd-main-accent-color)';\n this.#textDiv.style.cssText = 'position:relative; margin:auto; width:max-content; height:100%;';\n this.#text.style.cssText = 'user-select:none; color:white;';\n\n this.#textDiv.append(this.#text);\n this.#container.append(this.#progress, this.#textDiv);\n }\n\n start(total) {\n if (total <= 0) return;\n this.hide();\n this.#max = total;\n this.#interval = setInterval(() => this.update(this.#monitoredSet.size, this.#max), 100);\n }\n\n attachTo(element) {\n if (element.hasChildNodes) element.innerHTML = '';\n element.appendChild(this.#container);\n }\n\n hide() {\n this.#container.style.display = 'none';\n this.#visible = false;\n this.#progress.style.width = '0';\n this.#text.textContent = '';\n }\n\n update(loaded, max) {\n this.#progress.style.width = `${Math.floor((loaded / max) * 100)}%`;\n this.#text.textContent = `${loaded}/${max}`;\n if (!this.#visible) {\n this.#container.style.display = 'block';\n this.#visible = true;\n }\n if (loaded >= max) this.stop();\n }\n\n stop() {\n clearInterval(this.#interval);\n this.#interval = undefined;\n if (this.stats.count) {\n debug('gallery: thumbnail stats', this.stats);\n this.stats = { ...this.defaultStats };\n }\n setTimeout(() => this.hide(), 100);\n }\n}\n\nconst pb = new SimpleProgressBar(galleryHashes);\n\n/* This isn't as robust as the Web Locks API, but it will at least work if accessing a remote machine without HTTPS */\nclass SimpleFunctionQueue {\n #id;\n #running;\n #queue;\n\n constructor(id) {\n this.#id = id;\n this.#running = false;\n this.#queue = [];\n }\n\n static abortLogger(identifier, result) {\n if (typeof result === 'string' || (result instanceof DOMException && result.name === 'AbortError')) {\n log(identifier, typeof result === 'object' && result !== null ? (result as any).message || result : result);\n } else {\n error(identifier, result.message);\n }\n }\n\n /**\n * @param {{\n * signal: AbortSignal,\n * callback: Function\n * }} config\n */\n enqueue(config) {\n if (!(config.signal instanceof AbortSignal) || typeof config.callback !== 'function') {\n throw new Error('Invalid configuration. Object must contain an AbortSignal and a function');\n }\n if (config.signal.aborted) {\n debug(`${this.#id} Queue: Skipping addition to queue due to \"${config.signal.reason}\"`);\n return;\n }\n this.#queue.push(config);\n this.#tryRunNext();\n }\n\n async #tryRunNext() {\n if (this.#running || !this.#queue.length) return;\n try {\n const { signal, callback } = this.#queue.shift();\n if (signal.aborted) {\n return;\n }\n this.#running = true;\n if (callback.constructor.name.toLowerCase() === 'asyncfunction') {\n await callback();\n } else {\n callback();\n }\n } catch (err) {\n error(`${this.#id} Queue:`, err);\n } finally {\n this.#running = false;\n this.#tryRunNext();\n }\n }\n}\n\n// HTML Elements\n\nclass GalleryFolder extends HTMLElement {\n static folders = new Set();\n /** @type {GalleryFolder | null} */\n static #active = null;\n\n constructor(folder) {\n super();\n // Support both old format (string) and new format (object with path and label)\n if (typeof folder === 'object' && folder !== null) {\n this.name = decodeURI(folder.path || '');\n this.label = decodeURI(folder.label || folder.path || '');\n } else {\n this.name = decodeURI(folder);\n this.label = this.name;\n }\n this.style.overflowX = 'hidden';\n this.shadow = this.attachShadow({ mode: 'open' });\n this.shadow.adoptedStyleSheets = [folderStylesheet];\n\n this.div = document.createElement('div');\n }\n\n connectedCallback() {\n if (GalleryFolder.folders.has(this)) return; // Element is just being moved\n this.div.className = 'gallery-folder';\n this.div.innerHTML = `\\uf03e ${this.label}`;\n this.div.title = this.name; // Show full path on hover\n this.addEventListener('click', this.updateSelected);\n this.addEventListener('click', fetchFilesWS);\n this.shadow.appendChild(this.div);\n GalleryFolder.folders.add(this);\n if (this.name === currentGalleryFolder) {\n this.updateSelected();\n }\n }\n\n async disconnectedCallback() {\n await Promise.resolve(); // Wait for other microtasks (such as element moving)\n if (this.isConnected) return;\n GalleryFolder.folders.delete(this);\n if (GalleryFolder.#active === this) {\n GalleryFolder.#active = null;\n }\n }\n\n static getActive() {\n return GalleryFolder.#active;\n }\n\n updateSelected() {\n this.div.classList.add('gallery-folder-selected');\n GalleryFolder.#active = this;\n for (const folder of GalleryFolder.folders as any) {\n if (folder !== this) folder.div.classList.remove('gallery-folder-selected');\n }\n }\n}\n\n/**\n * Event-driven wait mechanism replacing the 50ms polling loop\n * @param {AbortSignal} signal - AbortController signal\n */\nasync function awaitForOutstanding(signal) {\n if (signal?.aborted) throw new DOMException('Aborted', 'AbortError');\n if (outstanding < maxFetchRequests) return; // if we are under the limit, proceed immediately\n await new Promise((resolve, reject) => { // otherwise, register a promise and wait for the queue to resolve us\n const onResolve = () => { // define what happens when this item gets its turn or gets aborted\n signal?.removeEventListener('abort', onAbort);\n resolve(true);\n };\n const onAbort = () => {\n const idx = fetchQueue.findIndex((item) => item.resolve === onResolve); // remove this specific request from the waiting queue if aborted\n if (idx !== -1) fetchQueue.splice(idx, 1);\n reject(new DOMException('Aborted', 'AbortError'));\n };\n fetchQueue.push({ resolve: onResolve });\n signal?.addEventListener('abort', onAbort);\n });\n}\n\nasync function delayFetchThumb(fn, signal) {\n const t0 = performance.now();\n try {\n await awaitForOutstanding(signal);\n } catch (err) {\n if ((err as DOMException).name === 'AbortError') return undefined;\n throw err;\n }\n pb.stats.queue = (pb.stats.queue || 0) + Math.round(performance.now() - t0);\n const t1 = performance.now();\n try {\n outstanding++;\n const ts = t0.toString();\n const res = await authFetch(`${window.api}/browser/thumb?file=${encodeURI(fn)}&ts=${ts}&exif=false`, { priority: 'low' });\n if (!res.ok) {\n error(`fetchThumb: ${res.statusText}`);\n return undefined;\n }\n const json = await res.json();\n if (!res || !json || json.error || Object.keys(json).length === 0) {\n if (json.error) error(`fetchThumb: ${json.error}`);\n return undefined;\n }\n return json;\n } finally {\n outstanding--;\n pb.stats.fetch = (pb.stats.fetch || 0) + Math.round(performance.now() - t1);\n if (fetchQueue.length > 0 && outstanding < maxFetchRequests) { // queue magic: trigger the next waiting fetch immediately\n const nextRequest = fetchQueue.shift();\n nextRequest.resolve(); // This wakes up the next awaitForOutstanding()\n }\n }\n}\n\nclass GalleryFile extends HTMLElement {\n /** @type {AbortSignal} */\n #signal;\n\n constructor(folder, file, signal) {\n super();\n this.folder = folder;\n this.name = file;\n this.#signal = signal;\n this.src = `${this.folder}/${this.name}`.replace(/\\/+/g, '/'); // Ensure no //, ///, etc...\n this.fullFolder = this.src.replace(/\\/[^/]+$/, '');\n this.size = 0;\n this.mtime = 0;\n this.hash = undefined;\n this.exif = '';\n this.width = 0;\n this.height = 0;\n this.shadow = this.attachShadow({ mode: 'open' });\n this.shadow.adoptedStyleSheets = [fileStylesheet];\n this.firstRun = true;\n }\n\n async connectedCallback() {\n if (!this.firstRun) return; // Element is just being moved\n this.firstRun = false;\n const t0 = performance.now();\n pb.stats.count = (pb.stats.count || 0) + 1;\n // Check separator state early to hide the element immediately\n const dir = this.name.match(/(.*)[/\\\\]/);\n if (dir && dir[1]) {\n const dirPath = dir[1];\n const isOpen = separatorStates.get(dirPath);\n if (isOpen === false) this.style.display = 'none';\n }\n\n this.hash = await getHash(`${this.src}/${this.size}/${this.mtime}`)\n .catch((err) => {\n error('getHash:', err);\n return null;\n });\n pb.stats.hash = (pb.stats.hash || 0) + Math.round(performance.now() - t0);\n let cachedData;\n if (opts.browser_cache) {\n const t1 = performance.now();\n // if (!pb.stats.keys) pb.stats.keys = await idbKeys();\n // if (pb.stats.keys && this.hash && pb.stats.keys.includes(this.hash)) cachedData = await idbGet(this.hash).catch(() => undefined);\n cachedData = await idbGet(this.hash).catch(() => undefined);\n pb.stats.db = (pb.stats.db || 0) + Math.round(performance.now() - t1);\n }\n const img = document.createElement('img');\n img.className = 'gallery-file';\n img.loading = 'lazy';\n img.onload = async () => {\n img.title += `\\nResolution: ${this.width} x ${this.height}`;\n this.title = img.title;\n if (!cachedData && opts.browser_cache) {\n if ((this.width === 0) || (this.height === 0)) { // fetch thumb failed so we use actual image\n this.width = img.naturalWidth;\n this.height = img.naturalHeight;\n }\n }\n };\n let ok = true;\n if (cachedData?.img) {\n img.src = cachedData.img;\n this.exif = cachedData.exif;\n this.width = cachedData.width;\n this.height = cachedData.height;\n this.size = cachedData.size;\n this.mtime = new Date(cachedData.mtime);\n pb.stats.cached = (pb.stats.cached || 0) + 1;\n } else {\n try {\n const json = await delayFetchThumb(this.src, this.#signal);\n if (!json) {\n ok = false;\n pb.stats.failed = (pb.stats.failed || 0) + 1;\n } else {\n img.src = json.data;\n this.exif = json.exif;\n this.width = json.width;\n this.height = json.height;\n this.size = json.size;\n this.mtime = new Date(json.mtime);\n pb.stats.fetched = (pb.stats.fetched || 0) + 1;\n if (opts.browser_cache && this.hash) {\n idbAdd({\n hash: this.hash,\n folder: this.fullFolder,\n file: this.name,\n size: this.size,\n mtime: this.mtime,\n width: this.width,\n height: this.height,\n src: this.src,\n exif: this.exif,\n img: img.src,\n // exif: await getExif(img), // alternative client-side exif\n // img: await createThumb(img), // alternative client-side thumb\n });\n }\n }\n } catch (err) { // thumb fetch failed so assign actual image\n img.src = `file=${this.src}`;\n pb.stats.error = (pb.stats.error || 0) + 1;\n }\n }\n pb.stats.callback = (pb.stats.callback || 0) + Math.round(performance.now() - t0);\n if (this.#signal.aborted) return;\n galleryHashes.add(this.hash);\n if (!ok) return;\n\n img.onclick = () => {\n setGallerySelectionByElement(this, { send: true });\n };\n img.onpointerenter = () => {\n el.overlay.display = 'block';\n this.shadow.appendChild(el.overlay);\n currentImage = this.src;\n currentName = this.name;\n currentTitle = this.title;\n };\n img.onpointerleave = () => {\n el.overlay.display = 'none';\n };\n img.title = `Folder: ${this.folder}\\nFile: ${this.name}\\nSize: ${this.size.toLocaleString()} bytes\\nModified: ${this.mtime.toLocaleString()}`;\n this.title = img.title;\n const shouldDisplayBasedOnSearch = this.title.toLowerCase().includes(el.search.value.toLowerCase()); // Final visibility check based on search term.\n if (this.style.display !== 'none') this.style.display = shouldDisplayBasedOnSearch ? 'flex' : 'none'; // Only proceed if not already hidden by a closed separator\n this.shadow.appendChild(img);\n pb.stats.elapsed = (pb.stats.elapsed || 0) + Math.round(performance.now() - t0);\n }\n}\n\nasync function createThumb(img) {\n const sizeEl = document.getElementById('gallery-thumb-size');\n currentSize = sizeEl ? parseInt(sizeEl.value, 10) : opts.extra_networks_card_size;\n const height = currentSize;\n const width = opts.browser_fixed_width ? currentSize : 0;\n const canvas = document.createElement('canvas');\n const scaleY = height / img.height;\n const scaleX = width > 0 ? width / img.width : scaleY;\n const scale = Math.min(scaleX, scaleY);\n const scaledWidth = img.width * scale;\n const scaledHeight = img.height * scale;\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n const ctx = canvas.getContext('2d');\n ctx.drawImage(img, 0, 0, scaledWidth, scaledHeight);\n const dataURL = canvas.toDataURL('image/jpeg', 0.5);\n return dataURL;\n}\n\nasync function handleSeparator(separator) {\n separator.classList.toggle('gallery-separator-hidden');\n const nowHidden = separator.classList.contains('gallery-separator-hidden');\n\n // Store the state (true = open, false = closed)\n separatorStates.set(separator.title, !nowHidden);\n\n // Update arrow and count\n const arrow = separator.querySelector('.gallery-separator-arrow');\n arrow.style.transform = nowHidden ? 'rotate(0deg)' : 'rotate(90deg)';\n\n const all = Array.from(el.files.children);\n for (const f of all) {\n if (!f.name) continue; // Skip separators\n\n // Check if file belongs to this exact directory\n const fileDir = f.name.match(/(.*)[/\\\\]/);\n const fileDirPath = fileDir ? fileDir[1] : '';\n\n if (separator.title.length > 0 && fileDirPath === separator.title) {\n f.style.display = nowHidden ? 'none' : 'unset';\n }\n }\n // Note: Count is not updated here on manual toggle, as it reflects the total.\n // If I end up implementing it, the search function will handle dynamic count updates.\n}\n\nasync function addSeparators() {\n document.querySelectorAll('.gallery-separator').forEach((node) => { el.files.removeChild(node); });\n const all = Array.from(el.files.children);\n let lastDir;\n\n // Count root files (files without a directory path)\n const hasRootFiles = all.some((f) => f.name && !f.name.match(/[/\\\\]/));\n // Only auto-open first separator if there are no root files to display\n let isFirstSeparator = !hasRootFiles;\n\n // First pass: create separators\n for (const f of all) {\n let dir = f.name?.match(/(.*)[/\\\\]/);\n if (!dir) dir = '';\n else dir = dir[1];\n if (dir !== lastDir) {\n lastDir = dir;\n if (dir.length > 0) {\n // Count files in this directory\n let fileCount = 0;\n for (const file of all) {\n if (!file.name) continue;\n const fileDir = file.name.match(/(.*)[/\\\\]/);\n const fileDirPath = fileDir ? fileDir[1] : '';\n if (fileDirPath === dir) fileCount++;\n }\n\n const sep = document.createElement('div');\n sep.className = 'gallery-separator';\n sep.title = dir;\n\n // Default to open for the first separator if no state is saved, otherwise closed.\n const isOpen = separatorStates.has(dir) ? separatorStates.get(dir) : isFirstSeparator;\n separatorStates.set(dir, isOpen); // Ensure it's in the map\n if (isFirstSeparator) isFirstSeparator = false; // Subsequent separators will default to closed\n\n if (!isOpen) {\n sep.classList.add('gallery-separator-hidden');\n }\n\n // Create arrow span\n const arrow = document.createElement('span');\n arrow.className = 'gallery-separator-arrow';\n arrow.textContent = '\u25B6';\n arrow.style.transform = isOpen ? 'rotate(90deg)' : 'rotate(0deg)';\n\n // Create directory name span\n const dirName = document.createElement('span');\n dirName.className = 'gallery-separator-name';\n dirName.textContent = dir;\n dirName.title = dir; // Show full path on hover\n\n // Create count span\n const count = document.createElement('span');\n count.className = 'gallery-separator-count';\n count.textContent = `${fileCount} files`;\n sep.dataset.totalFiles = String(fileCount); // Store total count for search filtering\n\n sep.appendChild(arrow);\n sep.appendChild(dirName);\n sep.appendChild(count);\n\n sep.onclick = () => handleSeparator(sep);\n el.files.insertBefore(sep, f);\n }\n }\n }\n\n // Second pass: hide files in closed directories\n for (const f of all) {\n if (!f.name) continue; // Skip separators\n\n const dir = f.name.match(/(.*)[/\\\\]/);\n if (dir && dir[1]) {\n const dirPath = dir[1];\n const isOpen = separatorStates.get(dirPath);\n if (isOpen === false) {\n f.style.display = 'none';\n }\n }\n }\n}\n\n// methods\n\nconst gallerySendImage = (_images) => [currentImage]; // invoked by gradio button\nwindow.gallerySendImage = gallerySendImage;\n\n/**\n * Helper function to update status with sort mode\n * @param {...string|[string, string]} messages - Each can be either a string to use as-is, or an array of a string label and value\n * @returns {void}\n */\nfunction updateStatusWithSort(...messages) {\n if (!el.status) return;\n messages.unshift(['Sort', sortMode.name]);\n const fragment = document.createDocumentFragment();\n for (let i = 0; i < messages.length; i++) {\n const div = document.createElement('div');\n if (Array.isArray(messages[i])) {\n const [text1, text2] = messages[i];\n const tDiv1 = document.createElement('div');\n tDiv1.innerText = `${text1}:`;\n const tDiv2 = document.createElement('div');\n tDiv2.innerText = text2;\n tDiv2.title = text2;\n div.append(tDiv1, tDiv2);\n } else {\n const tDiv1 = document.createElement('div');\n tDiv1.innerText = messages[i];\n div.append(tDiv1);\n }\n fragment.append(div);\n }\n if (el.status.hasChildNodes()) el.status.innerHTML = '';\n el.status.append(fragment);\n}\n\nasync function injectGalleryStatusCSS() {\n const style = document.createElement('style');\n style.textContent = `\n #tab-gallery-status {\n display: inline-flex;\n flex-flow: row wrap;\n justify-content: ${opts.theme_type?.toLowerCase() === 'modern' ? 'flex-start' : 'flex-end'};\n }\n #tab-gallery-status > div {\n display: flex;\n max-width: 100%;\n white-space: nowrap;\n & div {\n &:first-child {\n flex-shrink: 0;\n margin-right: 4px;\n }\n &:last-child:not(:first-child) {\n flex-shrink: 1;\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n direction: rtl;\n text-align: left;\n }\n }\n }\n #tab-gallery-status > div:not(:last-child)::after {\n content: '|';\n margin-inline: 6px;\n }`;\n document.head.append(style);\n}\n\nasync function wsConnect(socket, timeout = 5000) {\n const intrasleep = 100;\n const ttl = timeout / intrasleep;\n const isOpened = () => (socket.readyState === WebSocket.OPEN);\n if (socket.readyState !== WebSocket.CONNECTING) return isOpened();\n\n let loop = 0;\n while (socket.readyState === WebSocket.CONNECTING && loop < ttl) {\n await new Promise((resolve) => { setTimeout(resolve, intrasleep); });\n loop++;\n }\n return isOpened();\n}\n\nasync function gallerySearch() {\n if (el.search.busy) clearTimeout(el.search.busy);\n el.search.busy = setTimeout(async () => {\n const t0 = performance.now();\n const str = el.search.value.toLowerCase();\n const allFiles = Array.from(el.files.children).filter((node) => node.name);\n const allSeparators = Array.from(el.files.children).filter((node) => node.classList.contains('gallery-separator'));\n\n // If search is cleared, restore original view\n if (str === '') {\n allSeparators.forEach((sep) => {\n sep.style.display = 'flex';\n const isOpen = separatorStates.has(sep.title) ? separatorStates.get(sep.title) : false;\n\n const countSpan = sep.querySelector('.gallery-separator-count');\n if (countSpan && sep.dataset.totalFiles) {\n countSpan.textContent = `${sep.dataset.totalFiles} files`;\n }\n\n const arrow = sep.querySelector('.gallery-separator-arrow');\n sep.classList.toggle('gallery-separator-hidden', !isOpen);\n if (arrow) arrow.style.transform = isOpen ? 'rotate(90deg)' : 'rotate(0deg)';\n });\n\n allFiles.forEach((f) => {\n const dir = f.name.match(/(.*)[/\\\\]/);\n const dirPath = (dir && dir[1]) ? dir[1] : '';\n const isOpen = separatorStates.get(dirPath);\n f.style.display = (!dirPath || isOpen) ? 'unset' : 'none';\n });\n\n updateStatusWithSort('Filter', 'Cleared', ['Images', allFiles.length.toLocaleString()]);\n return;\n }\n\n // --- Search logic ---\n let totalFound = 0;\n const directoryMatches = new Map();\n const fileMatches = new WeakSet();\n const r = /^(.+)([=<>])(.*)/;\n\n for (const f of allFiles) {\n let isMatch = false;\n if (r.test(str)) {\n const match = str.match(r);\n const key = match[1].trim();\n const op = match[2].trim();\n let val = match[3].trim();\n if (key === 'mtime') val = new Date(val);\n if (((op === '=') && (f[key] === val)) || ((op === '>') && (f[key] > val)) || ((op === '<') && (f[key] < val))) {\n isMatch = true;\n }\n } else if (f.title?.toLowerCase().includes(str) || f.exif?.toLowerCase().includes(str)) {\n isMatch = true;\n }\n\n if (isMatch) {\n fileMatches.add(f);\n totalFound++;\n const dir = f.name.match(/(.*)[/\\\\]/);\n const dirPath = (dir && dir[1]) ? dir[1] : '';\n directoryMatches.set(dirPath, (directoryMatches.get(dirPath) || 0) + 1);\n }\n }\n\n // Update separators based on search results\n for (const sep of allSeparators) {\n const dirPath = sep.title;\n const foundCount = directoryMatches.get(dirPath) || 0;\n\n if (foundCount > 0) {\n sep.style.display = 'flex'; // Show separator\n sep.classList.remove('gallery-separator-hidden'); // Force open\n\n const arrow = sep.querySelector('.gallery-separator-arrow');\n if (arrow) arrow.style.transform = 'rotate(90deg)';\n\n // Removed file count update during search as it was buggy.\n } else {\n sep.style.display = 'none'; // Hide separator\n }\n }\n\n // Update file visibility\n for (const f of allFiles) {\n f.style.display = fileMatches.has(f) ? 'unset' : 'none';\n }\n\n const t1 = performance.now();\n updateStatusWithSort('Filter', ['Images', `${totalFound.toLocaleString()} / ${allFiles.length.toLocaleString()}`], `${iconStopwatch} ${Math.round(t1 - t0).toLocaleString()}ms`);\n timer(`galleryFilter:${str}`, t1 - t0);\n refreshGallerySelection();\n }, 250);\n}\n\nconst findDuplicates = (arr, key) => {\n const map = new Map();\n return arr.filter((item) => {\n const value = item[key];\n if (map.has(value)) return true;\n map.set(value, true);\n return false;\n });\n};\n\nexport async function gallerySort(key) {\n // if currentSort does not start with key, default to key+A\n // else if currentSort ends with A change to D and vice versa for toggling sort order\n if (currentSort.startsWith(key)) currentSort = currentSort.endsWith('A') ? `${key}D` : `${key}A`;\n else currentSort = `${key}A`;\n\n if (!Object.hasOwn(gallerySorter, currentSort)) {\n error(`Gallery: \"${currentSort}\" is not a valid gallery sorting key`);\n return;\n }\n const t0 = performance.now();\n const arr = Array.from(el.files.children).filter((node) => node.name); // filter out separators\n if (arr.length === 0) return; // no files to sort\n const fragment = document.createDocumentFragment();\n\n // Helper to get directory path from a file node\n const getDirPath = (node) => {\n const match = node.name.match(/(.*)[/\\\\]/);\n return match ? match[1] : '';\n };\n\n // Partition into root files and subfolder files - root files always stay at top\n const rootFiles = arr.filter((node) => !getDirPath(node));\n const subfolderFiles = arr.filter((node) => getDirPath(node));\n\n // Group subfolder files by directory\n const folderGroups = new Map();\n for (const file of subfolderFiles) {\n const dir = getDirPath(file);\n if (!folderGroups.has(dir)) {\n folderGroups.set(dir, []);\n }\n folderGroups.get(dir).push(file);\n }\n\n sortMode = gallerySorter[currentSort];\n\n // Sort root files\n rootFiles.sort(sortMode.func);\n rootFiles.forEach((node) => fragment.appendChild(node));\n\n // Sort folder names alphabetically, then sort files within each folder\n const sortedFolderNames = Array.from(folderGroups.keys()).sort((a, b) => a.localeCompare(b));\n for (const folderName of sortedFolderNames) {\n const files = folderGroups.get(folderName);\n files.sort(sortMode.func);\n files.forEach((node) => fragment.appendChild(node));\n }\n\n if (fragment.children.length === 0) return;\n el.files.innerHTML = '';\n el.files.appendChild(fragment);\n addSeparators();\n\n // After sorting and adding separators, ensure files respect separator states\n const all = Array.from(el.files.children);\n for (const f of all) {\n if (!f.name) continue; // Skip separators\n\n const dir = f.name.match(/(.*)[/\\\\]/);\n if (dir && dir[1]) {\n const dirPath = dir[1];\n const isOpen = separatorStates.get(dirPath);\n if (isOpen === false) {\n f.style.display = 'none';\n }\n }\n }\n\n const t1 = performance.now();\n log(`gallerySort: sort=${sortMode.name} len=${arr.length} time=${Math.floor(t1 - t0)}`);\n updateStatusWithSort(['Images', arr.length.toLocaleString()], `${iconStopwatch} ${Math.round(t1 - t0).toLocaleString()}ms`);\n timer(`gallerySort:${sortMode.name}`, t1 - t0);\n refreshGallerySelection();\n}\nwindow.gallerySort = gallerySort;\n\n/**\n * Function for removing the cleaning overlay\n * @callback ClearMsgCallback\n * @returns {void}\n */\n\n/**\n * Generate and display the overlay to announce cleanup is in progress.\n * @param {number} count - Number of entries being cleaned up\n * @param {boolean} all - Indicate that all thumbnails are being cleared\n * @returns {ClearMsgCallback}\n */\nfunction showCleaningMsg(count, all = false) {\n // Rendering performance isn't a priority since this doesn't run often\n const parent = el.folders.parentElement;\n const cleaningOverlay = document.createElement('div');\n const msgDiv = document.createElement('div');\n const msgText = document.createElement('div');\n const msgInfo = document.createElement('div');\n const anim = document.createElement('span');\n\n parent.style.position = 'relative';\n cleaningOverlay.style.cssText = 'position: absolute; height: 100%; width: 100%; background-color: var(--sd-main-accent-color); display: flex; align-items: center; justify-content: center; align-content: center; flex-wrap: wrap; opacity: 0.8; border-radius: var(--sd-border-radius);';\n msgDiv.style.cssText = 'display: block; color: var(--sd-button-normal-color); padding: 12px; border-radius: 8px; border-radius: var(--sd-border-radius);';\n msgText.style.cssText = 'font-size: 1.2em';\n msgInfo.style.cssText = 'font-size: 0.9em; text-align: center;';\n msgText.innerText = 'Thumbnail cleanup...';\n msgInfo.innerText = all ? 'Clearing all entries' : `Found ${count} old entries`;\n anim.classList.add('idbBusyAnim');\n\n msgDiv.append(msgText, msgInfo);\n cleaningOverlay.append(msgDiv, anim);\n parent.append(cleaningOverlay);\n return () => { cleaningOverlay.remove(); };\n}\n\nconst maintenanceQueue = new SimpleFunctionQueue('Gallery Maintenance');\n\n/**\n * Handles calling the cleanup function for the thumbnail cache\n * @param {string} folder - Folder to clean\n * @param {number} imgCount - Expected number of images in gallery\n * @param {AbortController} controller - AbortController that's handling this task\n * @param {boolean} force - Force full cleanup of the folder\n */\nasync function thumbCacheCleanup(folder, imgCount, controller, force = false) {\n if (!opts.browser_cache && !force) return;\n if (!folder || !imgCount) return;\n if (Date.now() - cleanupTimers[folder] < minCleanupTime) return; // Prevents multiple calls in quick succession\n cleanupTimers[folder] = Date.now();\n try {\n if (typeof folder !== 'string' || typeof imgCount !== 'number') {\n throw new Error('Function called with invalid arguments');\n }\n debug('thumbCacheCleanup', { folder, imgCount });\n await awaitForGallery(imgCount, controller.signal);\n } catch (err) {\n error('thumbCacheCleanup', { folder, error: err });\n return;\n }\n\n maintenanceQueue.enqueue({\n signal: controller.signal,\n callback: async () => {\n if (Date.now() - maintenanceTimers[folder] < minCleanupTime) return;\n maintenanceTimers[folder] = Date.now();\n const t0 = performance.now();\n const keptGalleryHashes = force ? new Set() : new Set(galleryHashes.values()); // External context should be safe since this function run is guarded by AbortController/AbortSignal in the SimpleFunctionQueue\n const folderNormalized = folder.replace(/\\/+/g, '/').replace(/\\/$/, '');\n const recursiveFolder = IDBKeyRange.bound(folderNormalized, `${folderNormalized}\\uffff`, false, true);\n if (keptGalleryHashes.size < minCleanupCount && !force) return; // Don't run when there aren't many excess entries\n const cachedHashesCount = await idbCount(recursiveFolder)\n .catch((e) => {\n error('maintenanceQueue', { folder, error: e });\n return Infinity; // Forces next check to fail if something went wrong\n });\n const cleanupCount = cachedHashesCount - keptGalleryHashes.size;\n if (!force && (cleanupCount < minCleanupCount || !Number.isFinite(cleanupCount))) return; // Don't run when there aren't many excess entries\n log('galleryMaintenance', { folder });\n\n if (controller.signal.aborted) {\n debug('maintenanceQueue', { folder, reason: controller.signal.reason });\n return;\n }\n const cb_clearMsg = showCleaningMsg(cleanupCount);\n await idbFolderCleanup(keptGalleryHashes, recursiveFolder, controller.signal)\n .then((delcount) => {\n const t1 = performance.now();\n log('galleryMaintenance', { folder, kept: keptGalleryHashes.size, deleted: delcount, time: Math.round(t1 - t0) });\n timer(`thumbnailDBCleanup:${folder}`, t1 - t0);\n currentGalleryFolder = null;\n updateStatusWithSort('Thumbnail cache cleared');\n })\n .catch((reason) => {\n SimpleFunctionQueue.abortLogger('thumbCacheCleanup', reason);\n })\n .finally(async () => {\n await new Promise((resolve) => { setTimeout(resolve, 1000); }); // Delay removal by 1 second to ensure at least minimum visibility\n cb_clearMsg();\n });\n },\n });\n}\n\nfunction resetGalleryState(reason) {\n maintenanceController.abort(reason);\n const controller = new AbortController();\n maintenanceController = controller;\n\n galleryHashes.clear(); // Must happen AFTER the AbortController steps\n pb.hide();\n resetGallerySelection();\n return controller;\n}\n\nfunction clearCacheIfDisabled(browser_cache) {\n if (browser_cache === false) {\n log('thumbCacheCleanup', { disabled: true });\n const controller = resetGalleryState('Clearing all thumbnails from cache');\n maintenanceQueue.enqueue({\n signal: controller.signal,\n callback: async () => {\n const t0 = performance.now();\n const cb_clearMsg = showCleaningMsg(0, true);\n await idbClearAll(controller.signal)\n .then(() => {\n log('thumbCacheCleanup', { time: Math.floor(performance.now() - t0) });\n currentGalleryFolder = null;\n updateStatusWithSort('Thumbnail cache cleared');\n })\n .catch((e) => {\n SimpleFunctionQueue.abortLogger('thumbCacheCleanup', e);\n })\n .finally(async () => {\n await new Promise((resolve) => { setTimeout(resolve, 1000); });\n cb_clearMsg();\n });\n },\n });\n }\n}\n\nexport function clearCache() {\n if (!currentGalleryFolder) return;\n const controller = resetGalleryState('Clearing folder thumbnails cache');\n el.files.innerHTML = '';\n log('clearCache', { folder: currentGalleryFolder });\n thumbCacheCleanup(currentGalleryFolder, 0, controller, true);\n}\nwindow.clearCache = clearCache;\n\nasync function fetchFilesHT(evt, controller) {\n const t0 = performance.now();\n const fragment = document.createDocumentFragment();\n updateStatusWithSort(['Folder', evt.target.name], 'in-progress');\n let numFiles = 0;\n\n const res = await authFetch(`${window.api}/browser/files?folder=${encodeURI(evt.target.name)}`);\n if (!res || res.status !== 200) {\n updateStatusWithSort(['Folder', evt.target.name], ['Failed', res?.statusText || 'No response']);\n return;\n }\n const jsonData = await res.json();\n for (const line of jsonData) {\n const data = decodeURI(line).split('##F##');\n const fileName = data[1];\n const ext = fileName.split('.').pop().toLowerCase();\n if (SUPPORTED_EXTENSIONS.includes(ext)) {\n numFiles++;\n const f = new GalleryFile(data[0], fileName, controller.signal);\n fragment.appendChild(f);\n }\n }\n\n if (controller.signal.aborted) return;\n el.files.appendChild(fragment);\n\n const t1 = performance.now();\n log(`gallery: folder=${evt.target.name} num=${numFiles} method=http time=${Math.floor(t1 - t0)}ms`);\n timer(`galleryFetch:${evt.target.name}`, t1 - t0);\n updateStatusWithSort(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`);\n pb.start(numFiles);\n addSeparators();\n refreshGallerySelection();\n thumbCacheCleanup(evt.target.name, numFiles, controller);\n}\n\nasync function fetchFilesWS(evt) { // fetch file-by-file list over websockets\n if (!url) return;\n // Abort previous controller and point to new controller for next time\n const controller = resetGalleryState('Gallery update'); // Called here because fetchFilesHT isn't called directly\n\n el.files.innerHTML = '';\n updateGalleryStyles();\n if (ws && ws.readyState === WebSocket.OPEN) ws.close(); // abort previous request\n let wsConnected = false;\n try {\n ws = new WebSocket(`${url}/sdapi/v1/browser/files`);\n wsConnected = await wsConnect(ws);\n } catch (err) {\n log('gallery: ws connect error', err);\n return;\n }\n log(`gallery: connected=${wsConnected} state=${ws?.readyState} url=${ws?.url}`);\n currentGalleryFolder = evt.target.name;\n if (!wsConnected) {\n await fetchFilesHT(evt, controller); // fallback to http\n return;\n }\n updateStatusWithSort(['Folder', evt.target.name]);\n const t0 = performance.now();\n let numFiles = 0;\n let t1 = performance.now();\n let fragment = document.createDocumentFragment();\n\n ws.onmessage = (event) => {\n t1 = performance.now();\n const data = decodeURI(event.data).split('##F##');\n if (data[0] === '#END#') {\n ws.close();\n } else {\n const fileName = data[1];\n const ext = fileName.split('.').pop().toLowerCase();\n if (SUPPORTED_EXTENSIONS.includes(ext)) {\n const file = new GalleryFile(data[0], fileName, controller.signal);\n numFiles++;\n fragment.appendChild(file);\n if (numFiles % fragmentSize === 0) {\n updateStatusWithSort(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], 'in-progress', `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`);\n el.files.appendChild(fragment);\n fragment = document.createDocumentFragment();\n }\n }\n }\n };\n ws.onclose = (event) => {\n if (controller.signal.aborted) return;\n el.files.appendChild(fragment);\n // gallerySort();\n log(`gallery: folder=${evt.target.name} num=${numFiles} method=ws time=${Math.floor(t1 - t0)}ms`);\n updateStatusWithSort(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`);\n pb.start(numFiles);\n addSeparators();\n refreshGallerySelection();\n thumbCacheCleanup(evt.target.name, numFiles, controller);\n };\n ws.onerror = (event) => {\n log('gallery ws error', event);\n };\n ws.send(encodeURI(evt.target.name));\n}\n\nasync function updateFolders() {\n // if (el.folders.children.length > 0) return;\n const res = await authFetch(`${window.api}/browser/folders`);\n if (!res || res.status !== 200) return;\n url = res.url.split('/sdapi')[0].replace('http', 'ws'); // update global url as ws need fqdn\n const folders = await res.json();\n el.folders.innerHTML = '';\n for (const folder of folders) {\n const f = new GalleryFolder(folder);\n el.folders.appendChild(f);\n }\n}\n\nasync function monitorGalleries() {\n async function galleryMutation(mutations) {\n const galleries = mutations.filter((m) => m.target?.classList?.contains('preview'));\n for (const gallery of galleries) {\n const links = gallery.target.querySelectorAll('a');\n for (const link of links) {\n const href = link.getAttribute('href');\n if (!href) continue;\n const fn = href.split('/').pop().split('\\\\').pop();\n link.setAttribute('download', fn);\n }\n }\n }\n\n const galleryElements = gradioApp().querySelectorAll('.gradio-gallery');\n for (const gallery of galleryElements) {\n const galleryObserver = new MutationObserver(galleryMutation);\n galleryObserver.observe(gallery, { childList: true, subtree: true, attributes: true });\n }\n}\n\nasync function setOverlayAnimation() {\n const busyAnimation = document.createElement('style');\n\n // eslint-disable-next-line @stylistic/max-len\n busyAnimation.textContent = '.idbBusyAnim{width:16px;height:16px;border-radius:50%;display:block;margin:40px;position:relative;background:#aa3d00;color:#fff;box-shadow:-24px 0,24px 0;box-sizing:border-box;animation:2s ease-in-out infinite overlayRotation}@keyframes overlayRotation{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}';\n document.head.append(busyAnimation);\n}\n\nasync function initGalleryAutoRefresh() {\n const isModern = opts.theme_type?.toLowerCase() === 'modern';\n let galleryTab = isModern ? document.getElementById('gallery_tabitem') : document.getElementById('tab_gallery');\n let timeout = 0;\n while (!galleryTab && timeout++ < 60) {\n await new Promise((resolve) => { setTimeout(resolve, 2500); });\n galleryTab = isModern ? document.getElementById('gallery_tabitem') : document.getElementById('tab_gallery');\n }\n if (!galleryTab) {\n error('Gallery: timeout');\n return;\n }\n const displayNoneRegEx = /display:\\s*none/;\n async function galleryAutoRefresh(mutations) {\n if (!opts.browser_gallery_autoupdate) return;\n for (const mutation of mutations) {\n switch (mutation.attributeName) {\n case 'class':\n if (mutation.oldValue.includes('hidden') && !mutation.target.classList.contains('hidden')) {\n await updateFolders();\n GalleryFolder.getActive()?.click();\n }\n break;\n case 'style':\n if (displayNoneRegEx.test(mutation.oldValue) && !displayNoneRegEx.test(mutation.target.style.display)) {\n await updateFolders();\n GalleryFolder.getActive()?.click();\n }\n break;\n default:\n break;\n }\n }\n }\n const galleryVisObserver = new MutationObserver(galleryAutoRefresh);\n galleryVisObserver.observe(galleryTab, { attributeFilter: ['class', 'style'], attributeOldValue: true });\n}\n\nasync function overlayDelete(evt) {\n const res = await authFetch(`${window.api}/delete-image?file=${encodeURIComponent(currentImage)}`);\n evt.stopPropagation();\n if (!res || res.status !== 200) {\n error('galleryDelete', { file: currentImage, status: res?.status, statusText: res?.statusText });\n return;\n }\n const data = await res.json();\n log('galleryDelete', data);\n GalleryFolder.getActive()?.click();\n}\n\nasync function overlayDownload(evt) {\n log('galleryDownload', currentImage);\n const link = document.createElement('a');\n link.href = `/file=${encodeURIComponent(currentImage)}`;\n link.download = currentName;\n document.body.appendChild(link);\n link.click();\n document.body.removeChild(link);\n evt.stopPropagation();\n}\n\nasync function overlayInfo(evt) {\n evt.stopPropagation();\n const tgt = document.getElementById('html_info_formatted_gallery');\n if (!tgt) return;\n const res = await authFetch(`${window.api}/png-info?file=${encodeURI(currentImage)}`);\n if (!res || res.status !== 200) return;\n const data = await res.json();\n log('galleryInfo res', data);\n const prompt = data?.parameters?.Prompt || '';\n const negative = data?.parameters?.Negative || data?.parameters?.['Negative prompt'] || '';\n const raw = data?.info || '';\n const params = data?.parameters || {};\n delete params.Prompt;\n delete params.Negative;\n delete params['Negative prompt'];\n const paramsFormatted = Object.entries(params).map(([key, value]) => `${key}: ${value}`).join(' | ');\n tgt.innerHTML = `\n
File: ${currentImage}
\n
Prompt: ${prompt}
\n
Negative: ${negative}
\n
${paramsFormatted}
\n
Raw:
${raw}
\n `;\n const img = document.querySelector('#gallery_gallery img');\n if (img) img.src = `/file=${encodeURIComponent(currentImage)}?t=${Date.now()}`; // Force refresh in case info endpoint is faster than cache update\n const status = document.querySelector('#html_log_gallery p');\n if (status) status.innerText = currentTitle;\n}\n\nasync function createOverlay() {\n if (el.overlay) return;\n el.overlay = document.createElement('div');\n el.overlay.className = 'gallery-overlay';\n const btnDownload = document.createElement('span');\n btnDownload.innerHTML = '\\udb85\\udc64';\n btnDownload.title = 'Download image';\n btnDownload.style.cursor = 'pointer';\n btnDownload.addEventListener('click', overlayDownload);\n const btnDelete = document.createElement('span');\n btnDelete.innerHTML = '\\uf05c';\n btnDelete.title = 'Delete image';\n btnDelete.style.cursor = 'pointer';\n btnDelete.addEventListener('click', overlayDelete);\n const btnInfo = document.createElement('span');\n btnInfo.innerHTML = '\\uf05a';\n btnInfo.title = 'Image metadata';\n btnInfo.style.cursor = 'pointer';\n btnInfo.addEventListener('click', overlayInfo);\n el.overlay.append(btnInfo, btnDelete, btnDownload);\n}\n\nasync function blockQueueUntilReady() {\n // Add block to maintenanceQueue until cache is ready\n maintenanceQueue.enqueue({\n signal: new AbortController().signal, // Use standalone AbortSignal that can't be aborted\n callback: async () => {\n let timeout = 0;\n while (!idbIsReady() && timeout++ < 60) {\n await new Promise((resolve) => { setTimeout(resolve, 1000); });\n }\n if (!idbIsReady()) {\n throw new Error('Timed out waiting for thumbnail cache');\n }\n },\n });\n}\n\nexport async function initGallery() { // triggered on gradio change to monitor when ui gets sufficiently constructed\n const t0 = performance.now();\n el.folders = gradioApp().getElementById('tab-gallery-folders');\n el.files = gradioApp().getElementById('tab-gallery-files');\n el.status = gradioApp().getElementById('tab-gallery-status');\n el.search = gradioApp().querySelector('#tab-gallery-search textarea');\n el.size = document.getElementById('tab-gallery-thumb-size');\n if (!el.folders || !el.files || !el.status || !el.search) {\n error('initGallery', 'Missing gallery elements');\n return;\n }\n\n if (el.size) {\n el.size.value = opts.extra_networks_card_size;\n el.size.addEventListener('input', updateGalleryStyles);\n }\n blockQueueUntilReady(); // Run first\n createOverlay();\n updateGalleryStyles();\n injectGalleryStatusCSS();\n setOverlayAnimation();\n\n const progress = gradioApp().getElementById('tab-gallery-progress');\n if (progress) pb.attachTo(progress);\n else log('initGallery', 'Failed to attach loading progress bar');\n\n el.search.addEventListener('input', gallerySearch);\n el.btnSend = gradioApp().getElementById('tab-gallery-send-image');\n document.getElementById('tab-gallery-files').style.height = opts.logmonitor_show ? '75vh' : '85vh';\n\n monitorGalleries();\n updateFolders();\n initGalleryAutoRefresh();\n [\n 'browser_folders',\n 'outdir_samples',\n 'outdir_txt2img_samples',\n 'outdir_img2img_samples',\n 'outdir_control_samples',\n 'outdir_extras_samples',\n 'outdir_save',\n 'outdir_video',\n 'outdir_init_images',\n 'outdir_grids',\n 'outdir_txt2img_grids',\n 'outdir_img2img_grids',\n 'outdir_control_grids',\n ].forEach((op) => { monitorOption(op, updateFolders); });\n const t1 = performance.now();\n log('initGallery', Math.round(t1 - t0));\n timer('initGallery', t1 - t0);\n}\n\n// register on startup\n\ncustomElements.define('gallery-folder', GalleryFolder);\ncustomElements.define('gallery-file', GalleryFile);\n", "import exifr from 'exifr';\nimport Panzoom from 'panzoom';\nimport { log, debug } from './logger';\nimport { gradioApp, onAfterUiUpdate } from './script';\nimport { getENActiveTab } from './extraNetworks';\nimport { all_gallery_buttons, selected_gallery_button } from './ui';\nimport { timer } from './timers';\n\n// A full size 'lightbox' preview modal shown when left clicking on gallery previews\nlet previewDrag = false;\nlet modalPreviewZone;\nlet previewInstance;\n\nfunction cycleImageFit() {\n const root = document.documentElement;\n const current = getComputedStyle(root).getPropertyValue('--sd-image-fit').trim();\n let next = 'contain';\n if (current === 'contain') next = 'cover';\n else if (current === 'cover') next = 'fill';\n else if (current === 'fill') next = 'scale-down';\n else if (current === 'scale-down') next = 'none';\n root.style.setProperty('--sd-image-fit', next);\n log('cycleImageFit', current, next);\n}\n\nwindow.cycleImageFit = cycleImageFit;\n\nfunction isInViewport(element) {\n const rect = element.getBoundingClientRect();\n return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);\n}\n\nfunction closeModal(evt, force = false) {\n if (force) gradioApp().getElementById('lightboxModal').style.display = 'none';\n if (previewDrag) return;\n if (evt?.button !== 0) return;\n gradioApp().getElementById('lightboxModal').style.display = 'none';\n let thumbnails = Array.from(gradioApp().querySelectorAll('.thumbnails .thumbnail-item'));\n thumbnails = thumbnails.filter((el) => el.checkVisibility());\n if (thumbnails.length === 0) return;\n thumbnails[0].focus();\n}\n\nfunction modalImageSwitch(offset) {\n const negmod = (n, m) => ((n % m) + m) % m;\n const galleryButtons = all_gallery_buttons();\n if (galleryButtons.length > 1) {\n const currentButton = selected_gallery_button();\n let result = -1;\n galleryButtons.forEach((v, i) => {\n if (v === currentButton) result = i;\n });\n if (result !== -1) {\n const nextButton = galleryButtons[negmod((result + offset), galleryButtons.length)];\n nextButton.click();\n const modalImage = gradioApp().getElementById('modalImage');\n const modal = gradioApp().getElementById('lightboxModal');\n modalImage.src = nextButton.children[0].src;\n if (modalImage.style.display === 'none') modal.style.setProperty('background-image', `url(${modalImage.src})`);\n return;\n }\n }\n\n const galleryFilesContainer = gradioApp().getElementById('tab-gallery-files');\n if (!galleryFilesContainer || !galleryFilesContainer.offsetParent) return;\n const gallerySelection = window.getGallerySelection();\n if (!gallerySelection.files.length || gallerySelection.files.length <= 1) return;\n const baseIndex = gallerySelection.index >= 0 ? gallerySelection.index : 0;\n const nextIndex = negmod((baseIndex + offset), gallerySelection.files.length);\n window.setGallerySelection(nextIndex, { send: true });\n const modalImage = gradioApp().getElementById('modalImage');\n const modal = gradioApp().getElementById('lightboxModal');\n const directSrc = window.getGallerySelectedUrl();\n if (modalImage && modal && directSrc) {\n modalImage.src = directSrc;\n if (modalImage.style.display === 'none') modal.style.setProperty('background-image', `url(${directSrc})`);\n }\n}\n\nfunction modalSaveImage(event?: any) {\n const tabName = getENActiveTab();\n const saveBtn = gradioApp().getElementById(`save_${tabName}`);\n log('modalSaveImage', tabName, saveBtn);\n if (saveBtn) saveBtn.click();\n modalImageSwitch(0);\n}\n\nfunction modalKeyHandler(event) {\n log('modalKeyHandler', event.key);\n switch (event.key) {\n case 's':\n modalSaveImage();\n break;\n case 'ArrowLeft':\n modalImageSwitch(-1);\n break;\n case 'ArrowRight':\n modalImageSwitch(1);\n break;\n case 'Escape':\n closeModal(null, true);\n break;\n }\n event.stopPropagation();\n}\n\nfunction decodeBytes(bytes: Uint8Array): string {\n if (!bytes || bytes.length < 8) return '';\n const prefix = new TextDecoder('ascii').decode(bytes.slice(0, 8));\n const data = bytes.slice(8);\n if (prefix.startsWith('ASCII')) return new TextDecoder('ascii').decode(data).replace(/\\0+$/, '');\n if (prefix.startsWith('UNICODE')) return new TextDecoder('utf-16be').decode(data).replace(/\\0+$/, '');\n if (prefix.startsWith('JIS')) return new TextDecoder('shift-jis').decode(data).replace(/\\0+$/, '');\n return new TextDecoder().decode(bytes).replace(/\\0+$/, '');\n}\n\nexport async function getExif(el) {\n let exif: any = '';\n try {\n exif = await exifr.parse(el, { userComment: true });\n } catch (e) {\n log('getExif', el, e);\n return exif;\n }\n // let html = `Image ${el.src} Size ${el.naturalWidth}x${el.naturalHeight}
`;\n let html = '';\n let params;\n if (!exif) {\n log('getExif', 'exif is none');\n return html;\n }\n if (exif.parameters) params = exif.parameters;\n else if (exif.userComment) params = decodeBytes(exif.userComment);\n else params = '';\n // debug('getExif', params);\n if (params.length > 0) html += `Prompt ${params || ''}
`;\n html = html.replace('Negative prompt:', '
Negative');\n html = html.replace('Steps:', '
Params Steps:');\n html = html.replaceAll('\\n', '
');\n html = html.replaceAll('

', '
');\n return html;\n}\n\nasync function displayExif(el) {\n const modalExif = gradioApp().getElementById('modalExif');\n const html = await getExif(el);\n modalExif.innerHTML = html;\n}\n\nfunction showModal(event) {\n const source = event.target || event.srcElement;\n const modalImage = gradioApp().getElementById('modalImage');\n const lb = gradioApp().getElementById('lightboxModal');\n lb.ownerSVGElement = modalImage;\n modalImage.onload = () => {\n previewInstance.moveTo(0, 0);\n modalPreviewZone.focus();\n if (opts.viewer_show_metadata) displayExif(modalImage);\n };\n modalImage.src = source.src;\n if (modalImage.style.display === 'none') lb.style.setProperty('background-image', `url(${source.src})`);\n lb.style.display = 'flex';\n lb.onkeydown = modalKeyHandler;\n event.stopPropagation();\n}\n\nfunction modalDownloadImage() {\n const link = document.createElement('a');\n link.style.display = 'none';\n link.href = gradioApp().getElementById('modalImage').src;\n link.download = 'image';\n document.body.appendChild(link);\n link.click();\n setTimeout(() => {\n URL.revokeObjectURL(link.href);\n link.parentNode.removeChild(link);\n }, 0);\n}\n\nfunction modalZoomSet(modalImage, enable) {\n localStorage.setItem('modalZoom', enable ? 'yes' : 'no');\n if (modalImage) modalImage.classList.toggle('modalImageFullscreen', !!enable);\n}\n\nfunction setupImageForLightbox(image) {\n if (image.dataset.modded) return;\n image.dataset.modded = 'true';\n image.style.cursor = 'pointer';\n image.style.userSelect = 'none';\n}\n\nfunction modalZoomToggle(event) {\n const modalImage = gradioApp().getElementById('modalImage');\n modalZoomSet(modalImage, !modalImage.classList.contains('modalImageFullscreen'));\n event.stopPropagation();\n modalImageSwitch(0);\n}\n\nfunction modalTileToggle(event) {\n const modalImage = gradioApp().getElementById('modalImage');\n const modal = gradioApp().getElementById('lightboxModal');\n const isTiling = modalImage.style.display === 'none';\n if (isTiling) {\n modalImage.style.display = 'block';\n modal.style.setProperty('background-image', 'none');\n } else {\n modalImage.style.display = 'none';\n modal.style.setProperty('background-image', `url(${modalImage.src})`);\n }\n event.stopPropagation();\n modalImageSwitch(0);\n}\n\nfunction modalResetInstance(event) {\n const modalImage = document.getElementById('modalImage');\n previewInstance.dispose();\n previewInstance = Panzoom(modalImage, { zoomSpeed: 0.05, minZoom: 0.1, maxZoom: 5.0, filterKey: (/* e, dx, dy, dz */) => true });\n event.stopPropagation();\n modalImageSwitch(0);\n}\n\nfunction modalToggleParams(event) {\n const modalExif = gradioApp().getElementById('modalExif');\n if (modalExif.style.display === 'none' || modalExif.style.display === '') {\n modalExif.style.display = 'block';\n } else {\n modalExif.style.display = 'none';\n }\n event.stopPropagation();\n modalImageSwitch(0);\n}\n\nfunction galleryClickEventHandler(event) {\n if (event.button !== 0) return;\n if (event.target.nodeName === 'IMG' && !event.target.parentNode.classList.contains('thumbnail-item')) {\n const initialZoom = (localStorage.getItem('modalZoom') || true) === 'yes';\n modalZoomSet(gradioApp().getElementById('modalImage'), initialZoom);\n event.preventDefault();\n showModal(event);\n }\n}\n\nasync function bindImageViewer() {\n // Each tab has its own gradio-gallery\n const galleryPreviews = gradioApp().querySelectorAll('.gradio-gallery > div.preview');\n for (const galleryPreview of galleryPreviews) {\n if (!galleryPreview.hasAttribute('data-listener')) galleryPreview.addEventListener('click', galleryClickEventHandler, true);\n galleryPreview.setAttribute('data-listener', 'true');\n galleryPreview.querySelectorAll('img').forEach(setupImageForLightbox);\n }\n}\n\nexport async function initImageViewer() {\n const t0 = performance.now();\n // main elements\n const modal = document.createElement('div');\n modal.id = 'lightboxModal';\n\n modalPreviewZone = document.createElement('div');\n modalPreviewZone.className = 'lightboxModalPreviewZone';\n\n const modalImage = document.createElement('img');\n modalImage.id = 'modalImage';\n modalPreviewZone.appendChild(modalImage);\n previewInstance = Panzoom(modalImage, { zoomSpeed: 0.05, minZoom: 0.1, maxZoom: 5.0, filterKey: (/* e, dx, dy, dz */) => true });\n\n // toolbar\n const modalZoom = document.createElement('span');\n modalZoom.id = 'modal_zoom';\n modalZoom.className = 'cursor';\n modalZoom.innerHTML = '\\uf531';\n modalZoom.title = 'Toggle zoomed view';\n modalZoom.addEventListener('click', modalZoomToggle, true);\n\n const modalReset = document.createElement('span');\n modalReset.id = 'modal_reset';\n modalReset.className = 'cursor';\n modalReset.innerHTML = '\\uf532';\n modalReset.title = 'Reset zoomed view';\n modalReset.addEventListener('click', modalResetInstance, true);\n\n const modalTile = document.createElement('span');\n modalTile.id = 'modal_tile';\n modalTile.className = 'cursor';\n modalTile.innerHTML = '\\udb81\\udd70';\n modalTile.title = 'Preview tiling';\n modalTile.addEventListener('click', modalTileToggle, true);\n\n const modalSave = document.createElement('span');\n modalSave.id = 'modal_save';\n modalSave.className = 'cursor';\n modalSave.innerHTML = '\\udb80\\udd93';\n modalSave.title = 'Save Image';\n modalSave.addEventListener('click', modalSaveImage, true);\n\n const modalDownload = document.createElement('span');\n modalDownload.id = 'modal_download';\n modalDownload.className = 'cursor';\n modalDownload.innerHTML = '\\udb85\\udc62';\n modalDownload.title = 'Download Image';\n modalDownload.addEventListener('click', modalDownloadImage, true);\n\n const modalClose = document.createElement('span');\n modalClose.id = 'modal_close';\n modalClose.className = 'cursor';\n modalClose.innerHTML = '\\udb80\\udd57';\n modalClose.title = 'Close';\n modalClose.addEventListener('click', (evt) => closeModal(evt, true), true);\n\n const modalToggleParamsBtn = document.createElement('span');\n modalToggleParamsBtn.id = 'modal_toggle_params';\n modalToggleParamsBtn.className = 'cursor';\n modalToggleParamsBtn.innerHTML = '\\uf05a';\n modalToggleParamsBtn.title = 'Toggle Parameters';\n modalToggleParamsBtn.addEventListener('click', modalToggleParams, true);\n\n // exif\n const modalExif = document.createElement('div');\n modalExif.id = 'modalExif';\n modalExif.style = 'position: absolute; bottom: 0px; width: 100%; background-color: rgba(0, 0, 0, 0.5); color: var(--neutral-300); padding: 1em; font-size: small; line-height: 1.2em; z-index: 1; display: none;';\n\n // handlers\n modalPreviewZone.addEventListener('mousedown', () => { previewDrag = false; });\n modalPreviewZone.addEventListener('touchstart', () => { previewDrag = false; }, { passive: true });\n modalPreviewZone.addEventListener('mousemove', () => { previewDrag = true; });\n modalPreviewZone.addEventListener('touchmove', () => { previewDrag = true; }, { passive: true });\n modalPreviewZone.addEventListener('scroll', () => { previewDrag = true; });\n modalPreviewZone.addEventListener('mouseup', (evt) => closeModal(evt));\n modalPreviewZone.addEventListener('touchend', (evt) => closeModal(evt));\n\n const modalPrev = document.createElement('a');\n modalPrev.className = 'modalPrev';\n modalPrev.innerHTML = '❮';\n modalPrev.addEventListener('click', () => modalImageSwitch(-1), true);\n // modalPrev.addEventListener('keydown', modalKeyHandler, true);\n\n const modalNext = document.createElement('a');\n modalNext.className = 'modalNext';\n modalNext.innerHTML = '❯';\n modalNext.addEventListener('click', () => modalImageSwitch(1), true);\n // modalNext.addEventListener('keydown', modalKeyHandler, true);\n\n const modalControls = document.createElement('div');\n modalControls.className = 'modalControls gradio-container';\n\n // build interface\n modal.appendChild(modalPrev);\n modal.appendChild(modalPreviewZone);\n modal.appendChild(modalNext);\n modal.append(modalControls);\n modalControls.appendChild(modalZoom);\n modalControls.appendChild(modalReset);\n modalControls.appendChild(modalTile);\n modalControls.appendChild(modalSave);\n modalControls.appendChild(modalDownload);\n modalControls.appendChild(modalToggleParamsBtn);\n modalControls.appendChild(modalClose);\n modal.append(modalExif);\n\n gradioApp().appendChild(modal);\n const t1 = performance.now();\n log('initImageViewer', Math.round(t1 - t0));\n timer('initImageViewer', t1 - t0);\n}\n\nonAfterUiUpdate(bindImageViewer);\n", "import { log } from './logger';\n\n/*\n * Extra-networks completion for SD.Next prompt textareas.\n *\n * Companion to autocomplete.js: exposes sorted indices for LoRAs, embeddings, and wildcards,\n * each backed by an existing enumeration endpoint. Dispatch and insertion are driven from\n * autocomplete.js via the mode returned by getCurrentWord().\n */\n\ninterface XnItem {\n name: string;\n display?: string;\n}\n\ninterface SearchItem {\n name: string;\n display: string;\n}\n\ntype SearchResult = SearchItem & { kind: 'lora' | 'embed' | 'wildcard' };\n\n/** Binary search for the first item where item.name >= query. */\nexport function lowerBound(items: { name: string }[], query: string): number {\n let lo = 0;\n let hi = items.length;\n while (lo < hi) {\n const mid = (lo + hi) >>> 1;\n if (items[mid].name < query) lo = mid + 1;\n else hi = mid;\n }\n return lo;\n}\n\ninterface XnEngine {\n lora: XnIndex;\n embed: XnIndex;\n wildcard: XnIndex;\n fetchJson(path: string): Promise;\n loadAll(): Promise;\n searchLoras(prefix: string, limit?: number): SearchResult[];\n searchEmbeddings(prefix: string, limit?: number): SearchResult[];\n searchWildcards(prefix: string, limit?: number): SearchResult[];\n}\n\n// -- Indices --\n\nclass XnIndex {\n items: SearchItem[];\n\n constructor(items: XnItem[]) {\n // items: [{ name, display }]. Sorted in-place by lowercase name.\n this.items = items.map(({ name, display }) => ({\n name: String(name).toLowerCase(),\n display: display ?? name,\n }));\n this.items.sort((a, b) => a.name.localeCompare(b.name));\n }\n\n search(prefix: string, limit = 20): SearchItem[] {\n const query = String(prefix).toLowerCase();\n // Empty query returns the first `limit` items so `= 3) {\n for (let i = 0; i < this.items.length && matches.length < limit; i++) {\n if (this.items[i].name.includes(query)) matches.push(this.items[i]);\n }\n }\n return matches.slice(0, limit);\n }\n}\n\n// -- Engine --\n\nexport const xnEngine: XnEngine = {\n lora: new XnIndex([]),\n embed: new XnIndex([]),\n wildcard: new XnIndex([]),\n\n async fetchJson(path) {\n try {\n const resp = await fetch(`${window.api}${path}`, { credentials: 'include' });\n if (!resp.ok) throw new Error(`${resp.status}`);\n return await resp.json();\n } catch (e) {\n log('autoComplete', { xnFetchFailed: path, error: String(e) });\n return null;\n }\n },\n\n async loadAll() {\n // LoRAs: [{name, alias, path, metadata}, ...]\n const loraData = await this.fetchJson('/loras');\n if (Array.isArray(loraData)) {\n const items: XnItem[] = [];\n for (const lo of loraData) {\n if (typeof lo === 'object' && lo && 'name' in lo && typeof lo.name === 'string') items.push({ name: lo.name });\n if (typeof lo === 'object' && lo && 'alias' in lo && typeof lo.alias === 'string' && lo.alias !== (lo as { name?: string }).name) items.push({ name: lo.alias });\n }\n this.lora = new XnIndex(items);\n }\n // Embeddings: {loaded: [...], skipped: [...]}\n const embData = await this.fetchJson('/embeddings') as Record | null;\n if (embData && typeof embData === 'object') {\n const loaded = Array.isArray(embData.loaded) ? embData.loaded : [];\n this.embed = new XnIndex(loaded.map((name) => ({ name: String(name) })));\n }\n // Wildcards: [{name}, ...]\n const wcData = await this.fetchJson('/wildcards');\n if (Array.isArray(wcData)) {\n this.wildcard = new XnIndex(\n wcData\n .filter((w) => typeof w === 'object' && w && 'name' in w && typeof w.name === 'string')\n .map((w) => ({ name: w.name })),\n );\n }\n log('autoComplete', {\n xnLoaded: true,\n lora: this.lora.items.length,\n embed: this.embed.items.length,\n wildcard: this.wildcard.items.length,\n });\n },\n\n searchLoras(prefix, limit = 20) {\n return this.lora.search(prefix, limit).map((item) => ({ ...item, kind: 'lora' as const }));\n },\n\n searchEmbeddings(prefix, limit = 20) {\n return this.embed.search(prefix, limit).map((item) => ({ ...item, kind: 'embed' as const }));\n },\n\n searchWildcards(prefix, limit = 20) {\n return this.wildcard.search(prefix, limit).map((item) => ({ ...item, kind: 'wildcard' as const }));\n },\n};\n", "import { xnEngine, lowerBound } from './autocomplete_xn';\nimport { log } from './logger';\nimport { gradioApp, onAfterUiUpdate, onOptionsChanged, executeCallbacks, optionsChangedCallbacks } from './script';\nimport { timer } from './timers';\nimport { updateInput } from './ui';\n\n/*\n * Tag autocomplete for SD.Next prompt textareas.\n *\n * Ported from Enso's CodeMirror-based autocomplete (autocomplete.ts).\n * Uses binary search on sorted tag arrays for O(log n) prefix lookup,\n * with substring fallback for 4+ char queries.\n */\n\n// -- Category colors (unified 14-category scheme) --\n\nconst CATEGORY_COLORS = {\n 0: '#0075f8', // general\n 1: '#cc0000', // artist\n 2: '#ff4500', // studio\n 3: '#9900ff', // copyright\n 4: '#00ab2c', // character\n 5: '#ed5d1f', // species\n 6: '#8a66ff', // genre\n 7: '#00cccc', // medium\n 8: '#6b7280', // meta\n 9: '#228b22', // lore\n 10: '#e67e22', // lens\n 11: '#f1c40f', // lighting\n 12: '#1abc9c', // composition\n 13: '#e84393', // color\n};\n\nconst CATEGORY_NAMES = {\n 0: 'general',\n 1: 'artist',\n 2: 'studio',\n 3: 'copyright',\n 4: 'character',\n 5: 'species',\n 6: 'genre',\n 7: 'medium',\n 8: 'meta',\n 9: 'lore',\n 10: 'lens',\n 11: 'lighting',\n 12: 'composition',\n 13: 'color',\n};\n\n// Glyph + color per result kind. Renders in place of the category dot for non-tag results.\nconst KIND_GLYPHS = {\n tag: { glyph: '\u25CF', color: null }, // color pulled from tag category\n lora: { glyph: '\u25C6', color: '#8a66ff' },\n embed: { glyph: '\u25B2', color: '#1abc9c' },\n wildcard: { glyph: '\u2605', color: '#f1c40f' },\n};\n\nlet active = false;\n\ninterface TagResult {\n name: string;\n display: string;\n category: number | string;\n count: number;\n aliases?: string[];\n matchedVia?: 'alias' | 'translation';\n matchedAlias?: string;\n matchedTerm?: string;\n}\n\n// -- Utilities (ported from Enso) --\n\n/** Format post count as abbreviated string. */\nfunction formatCount(count: number): string {\n if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;\n if (count >= 1_000) return `${Math.round(count / 1_000)}k`;\n return String(count);\n}\n\n/**\n * Estimate viewport Y of the bottom of the caret line using a persistent\n * offscreen mirror div. Styles and width are re-read from the textarea on\n * every call so resized textareas are handled correctly.\n */\nlet caretMirror: HTMLDivElement | null = null;\nlet caretMarker: HTMLSpanElement | null = null;\nconst MIRROR_PROPS = ['fontFamily', 'fontSize', 'fontWeight', 'fontStyle',\n 'lineHeight', 'letterSpacing', 'wordSpacing', 'textTransform',\n 'padding', 'border', 'boxSizing'];\n\nfunction caretViewportY(textarea: HTMLTextAreaElement): number {\n if (!caretMirror) {\n caretMirror = document.createElement('div');\n caretMirror.className = 'autocomplete-mirror';\n caretMirror.style.whiteSpace = 'pre-wrap';\n caretMirror.style.wordWrap = 'break-word';\n caretMirror.style.position = 'absolute';\n caretMirror.style.left = '-9999px';\n caretMirror.style.overflow = 'hidden';\n caretMarker = document.createElement('span');\n caretMarker.textContent = '\\u200b';\n document.body.appendChild(caretMirror);\n }\n const cs = getComputedStyle(textarea);\n for (const p of MIRROR_PROPS) caretMirror.style[p] = cs[p];\n caretMirror.style.width = `${textarea.offsetWidth}px`;\n caretMirror.textContent = textarea.value.substring(0, textarea.selectionStart);\n caretMirror.appendChild(caretMarker);\n const offset = caretMarker.offsetTop + caretMarker.offsetHeight;\n return textarea.getBoundingClientRect().top + offset - textarea.scrollTop;\n}\n\n// -- TagIndex --\n\nclass TagIndex {\n categories: Record;\n tags: TagResult[];\n aliasEntries: { name: string; display: string; tag: TagResult }[];\n translations: Map;\n tagByName: Map;\n translationEntries: { name: string; foreign: string; canonical: string }[];\n\n constructor(data: any) {\n this.categories = data.categories || {};\n // Tuples are [name, catId, count] or [name, catId, count, aliases]. Default `aliases = []`\n // keeps legacy 3-tuple dictionaries working unchanged.\n this.tags = data.tags.map(([name, category, count, aliases = []]) => ({\n name: name.toLowerCase(),\n display: name,\n category,\n count,\n aliases,\n }));\n this.tags.sort((a, b) => a.name.localeCompare(b.name));\n // Alias index parallel to this.tags. Each entry has .name so lowerBound works on both.\n this.aliasEntries = [];\n for (const tag of this.tags) {\n if (!tag.aliases || tag.aliases.length === 0) continue;\n for (const alias of tag.aliases) {\n this.aliasEntries.push({ name: alias.toLowerCase(), display: alias, tag });\n }\n }\n this.aliasEntries.sort((a, b) => a.name.localeCompare(b.name));\n // Optional translations companion: foreign_term -> canonical_tag_name.\n // tagByName is keyed on canonical lowercased name for O(1) resolution from a translation hit.\n this.translations = new Map();\n this.tagByName = new Map(this.tags.map((t) => [t.name, t]));\n if (data.translations && typeof data.translations === 'object') {\n for (const [foreign, canonical] of Object.entries(data.translations)) {\n if (typeof foreign !== 'string' || typeof canonical !== 'string') continue;\n this.translations.set(foreign.toLowerCase(), { canonical: canonical.toLowerCase(), foreign });\n }\n }\n // Sorted translation keys for prefix+substring scan via lowerBound.\n this.translationEntries = [...this.translations.entries()]\n .map(([foreignLower, { canonical, foreign }]) => ({ name: foreignLower, foreign, canonical }))\n .sort((a, b) => a.name.localeCompare(b.name));\n }\n\n /** Prefix search with binary search across canonical names and aliases. Returns matches sorted by count descending. */\n search(prefix: string, limit = 20): TagResult[] {\n const query = prefix.toLowerCase().replace(/ /g, '_');\n if (!query) return [];\n // Canonical prefix matches\n const matches = [];\n const start = lowerBound(this.tags, query);\n for (let i = start; i < this.tags.length && matches.length < limit * 5; i++) {\n if (!this.tags[i].name.startsWith(query)) break;\n matches.push(this.tags[i]);\n }\n // Alias prefix matches. Annotate so render can show \"canonical (alias)\".\n const aliasStart = lowerBound(this.aliasEntries, query);\n for (let i = aliasStart; i < this.aliasEntries.length && matches.length < limit * 10; i++) {\n const entry = this.aliasEntries[i];\n if (!entry.name.startsWith(query)) break;\n matches.push({ ...entry.tag, matchedVia: 'alias', matchedAlias: entry.display });\n }\n // Substring fallback (canonical + aliases) for 4+ char queries when prefix matching returned nothing.\n if (matches.length === 0 && query.length >= 4) {\n for (let i = 0; i < this.tags.length && matches.length < limit * 5; i++) {\n if (this.tags[i].name.includes(query)) matches.push(this.tags[i]);\n }\n for (let i = 0; i < this.aliasEntries.length && matches.length < limit * 10; i++) {\n const entry = this.aliasEntries[i];\n if (entry.name.includes(query)) matches.push({ ...entry.tag, matchedVia: 'alias', matchedAlias: entry.display });\n }\n }\n // Translation lookup. Prefix scan over foreign terms, resolving to canonical tags when present.\n if (this.translationEntries.length > 0) {\n const tStart = lowerBound(this.translationEntries, query);\n for (let i = tStart; i < this.translationEntries.length && matches.length < limit * 10; i++) {\n const entry = this.translationEntries[i];\n if (!entry.name.startsWith(query)) break;\n const canonicalTag = this.tagByName.get(entry.canonical);\n if (canonicalTag) matches.push({ ...canonicalTag, matchedVia: 'translation', matchedTerm: entry.foreign });\n }\n // Substring fallback over translation keys (CJK/short foreign terms benefit from 2-char threshold)\n if (query.length >= 2) {\n for (let i = 0; i < this.translationEntries.length && matches.length < limit * 10; i++) {\n const entry = this.translationEntries[i];\n if (entry.name.includes(query) && !entry.name.startsWith(query)) {\n const canonicalTag = this.tagByName.get(entry.canonical);\n if (canonicalTag) matches.push({ ...canonicalTag, matchedVia: 'translation', matchedTerm: entry.foreign });\n }\n }\n }\n }\n // Dedupe by canonical name; prefer canonical (no matchedVia) over alias/translation matches.\n const seen = new Map();\n for (const tag of matches) {\n const existing = seen.get(tag.name);\n if (!existing || (existing.matchedVia && !tag.matchedVia)) seen.set(tag.name, tag);\n }\n const result = [...seen.values()];\n result.sort((a, b) => b.count - a.count);\n return result.slice(0, limit);\n }\n}\n\n// -- Engine --\n\nconst engine = {\n indices: new Map(), // name -> TagIndex\n categoryColors: { ...CATEGORY_COLORS },\n categoryNames: { ...CATEGORY_NAMES },\n\n async loadEnabled() {\n const enabled = window.opts?.autocomplete_enabled || [];\n active = window.opts?.autocomplete_active || false;\n if (!active) {\n this.indices.clear();\n return;\n }\n const t0 = performance.now();\n const toLoad = enabled.filter((n) => !this.indices.has(n));\n const toRemove = [...this.indices.keys()].filter((n) => !enabled.includes(n));\n toRemove.forEach((n) => this.indices.delete(n));\n await Promise.all(toLoad.map(async (name) => {\n try {\n const resp = await fetch(`${window.api}/autocomplete/${name}`, { credentials: 'include' });\n if (!resp.ok) throw new Error(`${resp.status}`);\n const data = await resp.json();\n this.indices.set(name, new TagIndex(data));\n // Extract category colors from first loaded file\n if (data.categories) {\n Object.entries(data.categories).forEach(([id, cat]) => {\n const category: any = cat;\n if (category.color) this.categoryColors[id] = category.color;\n if (category.name) this.categoryNames[id] = category.name;\n });\n }\n const t1 = performance.now();\n log('autoComplete', { loaded: name, tags: data.tags?.length || 0, time: Math.round(t1 - t0) });\n timer(`autocompleteLoad:${name}`, t1 - t0);\n } catch (e) {\n log('autoComplete', { failed: name, error: e });\n }\n }));\n },\n\n searchAll(prefix, limit = 20) {\n if (this.indices.size === 0) return [];\n const all = [];\n this.indices.forEach((index) => {\n all.push(...index.search(prefix, limit));\n });\n // Deduplicate by name, keeping highest count\n const seen = new Map();\n all.forEach((tag) => {\n const existing = seen.get(tag.name);\n if (!existing || tag.count > existing.count) seen.set(tag.name, tag);\n });\n const results = [...seen.values()];\n results.sort((a, b) => b.count - a.count);\n return results.slice(0, limit);\n },\n};\n\n// -- Textarea integration --\n\n/**\n * Extract the current completion context at the cursor position.\n *\n * Returns { word, start, end, mode } where:\n * mode === 'tag': ordinary tag completion\n * mode === 'artist': leading `@` trigger; results filtered to artist category and inserted with `@` preserved\n * mode === 'lora': inside an unclosed ` 0) {\n const ch = value[wordStart - 1];\n if (ch === ',' || ch === '\\n') break;\n wordStart--;\n }\n // Skip leading whitespace between the separator and the typed word\n while (wordStart < selectionStart && value[wordStart] === ' ') wordStart++;\n const segment = value.slice(wordStart, selectionStart);\n // LoRA / extra-network trigger: unclosed `<` with `kind:` prefix\n const before = value.slice(0, selectionStart);\n const lastOpen = before.lastIndexOf('<');\n const lastClose = before.lastIndexOf('>');\n if (lastOpen > lastClose && lastOpen >= wordStart) {\n const inside = before.slice(lastOpen + 1); // e.g. \"lora:foo\", \"lora:\", \"lor\", or \"\"\n const colon = inside.indexOf(':');\n if (colon < 0) {\n // Bare `<` (or `` kind we ship,\n // so browse-all-loras; whatever the user typed gets overwritten on accept.\n return { word: '', start: lastOpen, end: selectionStart, mode: 'lora' };\n }\n if (inside.slice(0, colon).toLowerCase() === 'lora') {\n return { word: inside.slice(colon + 1), start: lastOpen, end: selectionStart, mode: 'lora' };\n }\n // Recognized colon but unknown kind, suppress completion.\n return null;\n }\n // Wildcard trigger: unclosed `__` that doesn't close within the current word\n if (segment.startsWith('__') && !segment.slice(2).includes('__')) {\n return { word: segment.slice(2), start: wordStart, end: selectionStart, mode: 'wildcard' };\n }\n // Artist trigger: leading `@` filters tag results to the artist category.\n if (segment.startsWith('@')) {\n return { word: segment.slice(1), start: wordStart, end: selectionStart, mode: 'artist' };\n }\n // Ordinary tag\n if (!segment) return null;\n return { word: segment, start: wordStart, end: selectionStart, mode: 'tag' };\n}\n\n// Booru schemas (danbooru/e621/sankaku) all assign category id 1 to artist tags.\nconst ARTIST_CATEGORY_ID = 1;\n\n/** Escape bare parens so tag names like `fate_(series)` aren't parsed as attention syntax. */\nfunction escapeParensForPrompt(name) {\n return name.replace(/([()])/g, '\\\\$1');\n}\n\n/**\n * Insert an extra-network reference at the current trigger position.\n * kind === 'lora': inserts `` over the range including the leading `<`\n * kind === 'wildcard': inserts `__name__` over the range including the leading `__`\n * Embeddings use insertTag directly so they go through comma-separator and paren-escape logic.\n */\nfunction insertExtraNetwork(textarea, item, kind) {\n const info = getCurrentWord(textarea);\n if (!info || info.mode !== kind) return;\n const { value } = textarea;\n const before = value.slice(0, info.start);\n const after = value.slice(info.end);\n let insertion;\n if (kind === 'lora') {\n insertion = ``;\n } else if (kind === 'wildcard') {\n insertion = `__${item.display ?? item.name}__`;\n } else {\n return;\n }\n textarea.value = before + insertion + after;\n const cursorPos = before.length + insertion.length;\n textarea.selectionStart = cursorPos;\n textarea.selectionEnd = cursorPos;\n if (typeof updateInput === 'function') updateInput(textarea);\n}\n\n/** Insert a tag at the current word position, replacing the typed prefix. */\nfunction insertTag(textarea, tagName, kind = 'tag') {\n const info = getCurrentWord(textarea);\n if (!info || (info.mode !== 'tag' && info.mode !== 'artist')) return;\n const { value } = textarea;\n const before = value.slice(0, info.start);\n const after = value.slice(info.end);\n // Build insertion: tag + separator. Parens in tag names are escaped so the prompt parser doesn't read them as attention syntax.\n const useComma = window.opts?.autocomplete_append_comma ?? true;\n const sep = useComma ? ',' : '';\n const needsSepBefore = before.length > 0 && before.trimEnd().length > 0 && !before.trimEnd().endsWith(',');\n const prefix = needsSepBefore ? `${sep} ` : '';\n let suffix = `${sep} `;\n if (after.length > 0 && after.trimStart().startsWith(',')) suffix = ' ';\n // Embedding names are file-system identifiers, so underscores must be preserved regardless of the user setting.\n // Tags and artists honor `autocomplete_keep_underscores`; default is to swap `_` for space.\n const keepUnderscores = window.opts?.autocomplete_keep_underscores ?? false;\n let body = tagName;\n if (kind !== 'embed' && !keepUnderscores) body = body.replace(/_/g, ' ');\n // Artist mode optionally keeps the `@` prefix (Anima syntax). The `@` is consumed for non-Anima models.\n if (info.mode === 'artist' && window.opts?.autocomplete_at_prefix_artist) body = `@${body}`;\n const insertion = `${prefix}${escapeParensForPrompt(body)}${suffix}`;\n textarea.value = before.trimEnd() + (before.trimEnd().length > 0 ? ' ' : '') + insertion + after.trimStart();\n // Position cursor after the inserted tag + separator\n const cursorPos = before.trimEnd().length + (before.trimEnd().length > 0 ? 1 : 0) + insertion.length;\n textarea.selectionStart = cursorPos;\n textarea.selectionEnd = cursorPos;\n // Sync with Gradio\n if (typeof updateInput === 'function') updateInput(textarea);\n}\n\n// -- Dropdown --\n\nconst dropdown = {\n el: null,\n listEl: null,\n selectedIndex: -1,\n results: [],\n textarea: null,\n query: '',\n visible: false,\n resizeObserver: null as ResizeObserver | null,\n\n init() {\n this.el = document.createElement('div');\n this.el.className = 'autocompleteResults';\n this.el.style.display = 'none';\n this.listEl = document.createElement('ul');\n this.listEl.className = 'autocompleteResultsList';\n this.el.appendChild(this.listEl);\n document.body.appendChild(this.el);\n this.el.addEventListener('mousedown', (e) => e.preventDefault()); // prevent blur on click\n this.el.addEventListener('click', (e) => {\n const li = e.target.closest('li');\n if (!li) return;\n const idx = [...this.listEl.children].indexOf(li);\n if (idx >= 0 && idx < this.results.length) {\n this.selectedIndex = idx;\n this.accept();\n }\n });\n this.resizeObserver = new ResizeObserver(() => {\n if (this.visible) this.position();\n });\n },\n\n show(results, textarea, query) {\n if (results.length === 0) { this.hide(); return; }\n // Switching textareas: clear prior state so a stale render can't leak across.\n if (this.textarea && this.textarea !== textarea) this.hide();\n if (this.textarea !== textarea) this.resizeObserver?.observe(textarea);\n this.results = results;\n this.textarea = textarea;\n this.query = query || '';\n this.selectedIndex = -1;\n this.render();\n this.position();\n this.el.style.display = '';\n this.visible = true;\n },\n\n hide() {\n if (this.textarea) this.resizeObserver?.unobserve(this.textarea);\n this.textarea = null;\n this.el.style.display = 'none';\n this.visible = false;\n this.results = [];\n this.selectedIndex = -1;\n },\n\n render() {\n const keepUnderscores = window.opts?.autocomplete_keep_underscores ?? false;\n const queryNorm = this.query.toLowerCase().replace(/ /g, '_');\n this.listEl.replaceChildren();\n this.results.forEach((tag, i) => {\n const li = document.createElement('li');\n if (i === this.selectedIndex) li.classList.add('selected');\n const dot = document.createElement('span');\n dot.className = 'autocomplete-category';\n const kind = tag.kind || 'tag';\n const kindStyle = KIND_GLYPHS[kind] || KIND_GLYPHS.tag;\n dot.style.color = kindStyle.color || engine.categoryColors[tag.category] || '#888';\n dot.textContent = kindStyle.glyph;\n dot.title = kind === 'tag' ? (engine.categoryNames[tag.category] || '') : kind;\n const name = document.createElement('span');\n name.className = 'autocomplete-tag';\n // Embeddings are file-name identifiers, so they always render as-is to match how they get inserted.\n const swapForKind = kind !== 'embed';\n const tagText = (swapForKind && !keepUnderscores) ? tag.display.replace(/_/g, ' ') : tag.display;\n const canonicalMatch = tag.name.indexOf(queryNorm);\n if (canonicalMatch >= 0 && queryNorm.length > 0) {\n const mark = document.createElement('mark');\n mark.textContent = tagText.slice(canonicalMatch, canonicalMatch + queryNorm.length);\n name.append(\n document.createTextNode(tagText.slice(0, canonicalMatch)),\n mark,\n document.createTextNode(tagText.slice(canonicalMatch + queryNorm.length)),\n );\n } else {\n name.textContent = tagText;\n }\n // Alias/translation-matched rows append \" (foreign)\" with the query fragment highlighted.\n let annotationTerm = null;\n if (tag.matchedVia === 'alias') annotationTerm = tag.matchedAlias;\n else if (tag.matchedVia === 'translation') annotationTerm = tag.matchedTerm;\n if (annotationTerm) {\n const annotationDisplay = (swapForKind && !keepUnderscores) ? annotationTerm.replace(/_/g, ' ') : annotationTerm;\n const annotationLower = annotationTerm.toLowerCase();\n const annotationMatch = annotationLower.indexOf(queryNorm);\n const prefix = tag.matchedVia === 'translation' ? ' \\u{1F310} ' : ' (';\n const suffix = tag.matchedVia === 'translation' ? '' : ')';\n name.appendChild(document.createTextNode(prefix));\n if (annotationMatch >= 0 && queryNorm.length > 0) {\n const mark = document.createElement('mark');\n mark.textContent = annotationDisplay.slice(annotationMatch, annotationMatch + queryNorm.length);\n name.append(\n document.createTextNode(annotationDisplay.slice(0, annotationMatch)),\n mark,\n document.createTextNode(annotationDisplay.slice(annotationMatch + queryNorm.length)),\n );\n } else {\n name.appendChild(document.createTextNode(annotationDisplay));\n }\n if (suffix) name.appendChild(document.createTextNode(suffix));\n }\n const count = document.createElement('span');\n count.className = 'autocomplete-count';\n count.textContent = tag.count > 0 ? formatCount(tag.count) : '';\n li.append(dot, name, count);\n li.addEventListener('mouseenter', () => {\n this.selectedIndex = i;\n this.updateSelection();\n });\n this.listEl.appendChild(li);\n });\n },\n\n position() {\n if (!this.textarea) return;\n const rect = this.textarea.getBoundingClientRect();\n // Position near the caret line instead of the textarea bottom\n const cursorBottom = caretViewportY(this.textarea);\n const anchorY = Math.max(rect.top, Math.min(cursorBottom, rect.bottom));\n const spaceBelow = window.innerHeight - anchorY;\n const dropHeight = Math.min(this.el.scrollHeight, 300);\n if (spaceBelow >= dropHeight || spaceBelow >= anchorY - rect.top) {\n this.el.style.top = `${anchorY + 2}px`;\n } else {\n this.el.style.top = `${anchorY - dropHeight - 2}px`;\n }\n this.el.style.left = `${rect.left}px`;\n this.el.style.width = `${rect.width}px`;\n },\n\n updateSelection() {\n [...this.listEl.children].forEach((li, i) => {\n li.classList.toggle('selected', i === this.selectedIndex);\n });\n const selected = this.listEl.children[this.selectedIndex];\n if (selected) selected.scrollIntoView({ block: 'nearest' });\n },\n\n navigate(dir) {\n if (this.results.length === 0) return;\n if (this.selectedIndex === -1) {\n this.selectedIndex = dir > 0 ? 0 : this.results.length - 1;\n } else {\n this.selectedIndex = (this.selectedIndex + dir + this.results.length) % this.results.length;\n }\n this.updateSelection();\n },\n\n accept() {\n if (this.selectedIndex < 0 || this.selectedIndex >= this.results.length) {\n // Tab with no selection: select first\n if (this.results.length > 0) {\n this.selectedIndex = 0;\n this.updateSelection();\n }\n return;\n }\n const result = this.results[this.selectedIndex];\n if (this.textarea) {\n if (result.kind === 'lora' || result.kind === 'wildcard') {\n insertExtraNetwork(this.textarea, result, result.kind);\n } else {\n // 'embed' kind and untagged tag results both go through insertTag (comma-aware, paren-escaped).\n insertTag(this.textarea, result.display ?? result.name, result.kind);\n }\n }\n this.hide();\n },\n};\n\n// -- Event handlers --\n\nlet debounceInput: ReturnType | undefined;\nlet debounceFocus: ReturnType | undefined;\n\nfunction onInput(textarea) {\n if (!active) return;\n // IME candidate window open: value isn't committed, and Enter would race with tag accept.\n if (textarea.dataset.imeActive === '1') return;\n const minChars = window.opts?.autocomplete_min_chars ?? 3;\n const info = getCurrentWord(textarea);\n if (!info) {\n dropdown.hide();\n return;\n }\n // Threshold by mode. Trigger characters carry their own signal so we can lower (or zero) the bar.\n let threshold = minChars;\n if (info.mode === 'lora' || info.mode === 'wildcard') threshold = 0;\n else if (info.mode === 'artist') threshold = 1;\n if (info.word.length < threshold) {\n dropdown.hide();\n return;\n }\n clearTimeout(debounceInput);\n debounceInput = setTimeout(() => {\n let results;\n if (info.mode === 'lora') {\n results = xnEngine.searchLoras(info.word);\n } else if (info.mode === 'wildcard') {\n results = xnEngine.searchWildcards(info.word);\n } else if (info.mode === 'artist') {\n // `@` trigger: tag-search filtered to the artist category. The category-1 color carries the visual cue.\n results = engine.searchAll(info.word).filter((t) => t.category === ARTIST_CATEGORY_ID);\n } else {\n const tagResults = engine.searchAll(info.word);\n const embedResults = xnEngine.searchEmbeddings(info.word);\n // Embeddings fold into tag-mode results (a1111 tagcomplete parity).\n results = [...embedResults, ...tagResults];\n }\n dropdown.show(results, textarea, info.word);\n }, 150);\n}\n\nfunction onKeyDown(e) {\n if (!dropdown.visible) return;\n if (e.isComposing) return; // IME candidate selection, let the browser commit the candidate\n // Modifier + nav/accept keys belong to other handlers (editAttention.js on Ctrl+Arrow,\n // generate hotkey on Ctrl+Enter). Let them through even with the dropdown open.\n const hasModifier = e.ctrlKey || e.metaKey || e.altKey;\n switch (e.key) {\n case 'ArrowDown':\n if (hasModifier) return;\n e.preventDefault();\n e.stopPropagation();\n dropdown.navigate(1);\n break;\n case 'ArrowUp':\n if (hasModifier) return;\n e.preventDefault();\n e.stopPropagation();\n dropdown.navigate(-1);\n break;\n case 'Enter':\n if (hasModifier) return;\n if (dropdown.selectedIndex >= 0) {\n e.preventDefault();\n e.stopPropagation();\n dropdown.accept();\n }\n break;\n case 'Tab':\n if (hasModifier) return;\n e.preventDefault();\n e.stopPropagation();\n dropdown.accept();\n break;\n case 'Escape':\n e.preventDefault();\n e.stopPropagation();\n dropdown.hide();\n break;\n default:\n break;\n }\n}\n\n/** Attach autocomplete to a single textarea. */\nfunction attachAutocomplete(textarea) {\n textarea.addEventListener('input', () => onInput(textarea));\n textarea.addEventListener('keydown', onKeyDown);\n textarea.addEventListener('compositionstart', () => { textarea.dataset.imeActive = '1'; });\n textarea.addEventListener('compositionend', () => { delete textarea.dataset.imeActive; });\n textarea.addEventListener('focusin', () => {\n if (dropdown.visible && dropdown.textarea && dropdown.textarea !== textarea) dropdown.hide();\n // Cancel any pending hide from a recent blur so refocusing within 200ms doesn't close the dropdown.\n clearTimeout(debounceFocus);\n debounceFocus = undefined;\n // Re-fire input handling so a partial tag at the cursor reopens the dropdown.\n onInput(textarea);\n });\n textarea.addEventListener('focusout', () => {\n // Cancel any in-flight debounced dropdown.show; otherwise it fires against a stale textarea.\n clearTimeout(debounceInput);\n debounceFocus = setTimeout(() => dropdown.hide(), 200);\n });\n}\n\n// -- Prompt textarea IDs --\n\nconst PROMPT_IDS = [\n 'txt2img_prompt', 'txt2img_neg_prompt',\n 'img2img_prompt', 'img2img_neg_prompt',\n 'control_prompt', 'control_neg_prompt',\n 'video_prompt', 'video_neg_prompt',\n];\n\n// -- Active button --\n\nfunction patchActiveButton() {\n const buttons = [...gradioApp().querySelectorAll('.autocomplete-active')];\n active = window.opts?.autocomplete_active || false;\n buttons.forEach((btn) => {\n btn.classList.toggle('autocomplete-active', active);\n btn.classList.toggle('autocomplete-inactive', !active);\n btn.parentElement.onclick = () => {\n active = !active;\n window.opts.autocomplete_active = !active;\n btn.classList.toggle('autocomplete-active', active);\n btn.classList.toggle('autocomplete-inactive', !active);\n };\n });\n}\n\n// -- Config bridge --\n\n/** Monkey-patch script config bridge textboxes to push autocomplete config changes to window.opts immediately. */\nlet bridgeWarnedMissingDescriptor = false;\nfunction patchConfigBridge() {\n const proto = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value');\n if (!proto?.get || !proto?.set) {\n if (!bridgeWarnedMissingDescriptor) {\n log('autoComplete', { bridge: 'skipped', reason: 'HTMLTextAreaElement.prototype.value descriptor missing' });\n bridgeWarnedMissingDescriptor = true;\n }\n return;\n }\n const elements = gradioApp().querySelectorAll('[id$=\"_tag_autocomplete_config_json\"]');\n for (const el of elements) {\n const textarea = el.querySelector('textarea');\n if (!textarea || textarea.acBridgePatched) continue;\n textarea.acBridgePatched = true;\n Object.defineProperty(textarea, 'value', {\n set(newValue) {\n const oldValue = proto.get.call(textarea);\n proto.set.call(textarea, newValue);\n if (oldValue !== newValue && newValue) {\n try {\n const cfg = JSON.parse(newValue);\n for (const [key, val] of Object.entries(cfg)) window.opts[key] = val;\n executeCallbacks(optionsChangedCallbacks);\n } catch { /* ignore parse errors; the bridge is best-effort */ }\n }\n },\n get() { return proto.get.call(textarea); },\n });\n }\n}\n\n// -- Initialization --\n\nexport async function initAutocomplete() {\n const t0 = performance.now();\n const enabled = window.opts?.autocomplete_enabled || [];\n active = window.opts?.autocomplete_active || false;\n log('autoComplete', { active, enabled });\n // Inject styles (CSS files in javascript/ are not auto-loaded)\n const style = document.createElement('style');\n style.textContent = `\n .autocompleteResults { position: fixed; z-index: 9999; max-height: 300px; overflow-y: auto;\n background: var(--sd-main-background-color, var(--background-fill-primary, #1f2937));\n border: 1px solid var(--sd-input-border-color, var(--border-color-primary, #374151));\n border-radius: var(--sd-border-radius, 6px); box-shadow: 0 4px 16px rgba(0,0,0,0.4);\n font-size: 13px; scrollbar-width: thin; color: var(--body-text-color-subdued); }\n .autocompleteResultsList { list-style: none; margin: 0; padding: 4px 0; }\n .autocompleteResultsList > li { display: flex; align-items: center; padding: 6px 12px; cursor: pointer;\n gap: 8px; line-height: 1.4; transition: background 0.1s ease; border-bottom: 1px solid rgba(255,255,255,0.03); }\n .autocompleteResultsList > li:last-child { border-bottom: none; }\n .autocompleteResultsList > li:hover { background: var(--sd-panel-background-color, var(--input-background-fill-focus, #374151)); }\n .autocompleteResultsList > li.selected { background: var(--sd-main-accent-color, var(--button-primary-background-fill, #4b5563)); }\n .autocomplete-category { font-size: 10px; flex-shrink: 0; width: 10px; text-align: center; cursor: help; }\n .autocomplete-tag { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }\n .autocomplete-tag mark { background: transparent; color: inherit; font-weight: 700; }\n .autocomplete-count { font-size: 0.75em; opacity: 0.45; flex-shrink: 0; font-variant-numeric: tabular-nums;\n background: rgba(255,255,255,0.06); padding: 1px 6px; border-radius: 8px; min-width: 28px; text-align: right; }\n `;\n document.head.appendChild(style);\n dropdown.init();\n await engine.loadEnabled();\n xnEngine.loadAll();\n // Attach to all prompt textareas; even if no dictionaries loaded yet, they may be enabled later via script UI\n let attached = 0;\n PROMPT_IDS.forEach((id) => {\n const textarea = gradioApp().querySelector(`#${id} > label > textarea`);\n if (textarea) {\n attachAutocomplete(textarea);\n attached++;\n }\n });\n // Reload when settings change\n\n async function optionsChangedCallback() {\n const newActive = window.opts?.autocomplete_active || false;\n const newEnabled = window.opts?.autocomplete_enabled || [];\n const currentKeys = [...engine.indices.keys()].sort().join(',');\n const newKeys = [...newEnabled].sort().join(',');\n if ((currentKeys !== newKeys) || (active !== newActive)) {\n log('autoComplete', { reload: newEnabled });\n await engine.loadEnabled();\n active = newActive;\n patchActiveButton();\n }\n xnEngine.loadAll();\n }\n onOptionsChanged(optionsChangedCallback);\n // Watch for config updates from the script UI bridge\n patchConfigBridge();\n patchActiveButton();\n onAfterUiUpdate(patchConfigBridge);\n const t1 = performance.now();\n log('autoComplete', { attached, dicts: engine.indices.size, time: Math.round(t1 - t0) });\n timer('autocompleteInit', t1 - t0);\n}\n", "/* eslint-disable @typescript-eslint/no-use-before-define */\nimport { log } from './logger';\nimport { gradioApp } from './script';\nimport { timer } from './timers';\n\nlet hintsObserver: MutationObserver | null = null;\nconst allLocales = ['en', 'tb', 'nb', 'hr', 'es', 'it', 'fr', 'de', 'pt', 'ru', 'zh', 'ja', 'ko', 'hi', 'ar', 'bn', 'ur', 'id', 'vi', 'tr', 'sr', 'po', 'he', 'xx', 'qq', 'tlh'];\nconst localeData = {\n prev: null,\n locale: null,\n data: [],\n timeout: null,\n finished: false,\n initial: true,\n type: 2,\n hint: null,\n btn: null,\n expandTimeout: undefined, // Property for expansion timeout\n currentElement: null, // Track current element for expansion\n};\nlet localeTimeout: ReturnType | undefined;\nconst isTouchDevice = 'ontouchstart' in window;\n\nasync function cycleLocale() {\n clearTimeout(localeTimeout);\n localeTimeout = setTimeout(() => {\n log('cycleLocale', localeData.prev, localeData.locale);\n const index = allLocales.indexOf(localeData.prev);\n localeData.locale = allLocales[(index + 1) % allLocales.length];\n localeData.btn.innerText = localeData.locale;\n // localeData.btn.style.backgroundColor = localeData.locale !== 'en' ? 'var(--primary-500)' : '';\n localeData.finished = false;\n localeData.data = [];\n localeData.prev = localeData.locale;\n window.opts.ui_locale = localeData.locale;\n setHints();\n }, 250);\n}\n\nasync function resetLocale() {\n clearTimeout(localeTimeout); // Prevent the single click logic\n localeData.locale = 'en';\n log('resetLocale', localeData.locale);\n const index = allLocales.indexOf(localeData.locale);\n localeData.locale = allLocales[(index) % allLocales.length];\n localeData.btn.innerText = localeData.locale;\n localeData.finished = false;\n localeData.data = [];\n window.opts.ui_locale = localeData.locale;\n setHints();\n}\n\nasync function tooltipCreate() {\n localeData.hint = document.createElement('div');\n localeData.hint.className = 'tooltip';\n localeData.hint.id = 'tooltip-container';\n localeData.hint.innerText = 'this is a hint';\n gradioApp().appendChild(localeData.hint);\n localeData.btn = gradioApp().getElementById('locale-container');\n if (!localeData.btn) {\n localeData.btn = document.createElement('div');\n localeData.btn.className = 'locale';\n localeData.btn.id = 'locale-container';\n gradioApp().appendChild(localeData.btn);\n }\n localeData.btn.innerText = localeData.locale;\n localeData.btn.ondblclick = resetLocale;\n localeData.btn.onclick = cycleLocale;\n if (window.opts.tooltips === 'None') localeData.type = 0;\n if (window.opts.tooltips === 'Browser default') localeData.type = 1;\n if (window.opts.tooltips === 'UI tooltips') localeData.type = 2;\n\n if (localeData.type === 2) { // setup event delegation for tooltips instead of individual listeners\n if (isTouchDevice) {\n gradioApp().addEventListener('touchstart', tooltipShowDelegated);\n gradioApp().addEventListener('touchend', tooltipHideDelegated);\n }\n gradioApp().addEventListener('pointerover', tooltipShowDelegated);\n gradioApp().addEventListener('pointerout', tooltipHideDelegated);\n }\n if (!hintsObserver) initializeDOMObserver();\n}\n\nasync function expandTooltip(element, longHint) {\n if (localeData.currentElement === element && localeData.hint.classList.contains('tooltip-show')) {\n const ring = localeData.hint.querySelector('.tooltip-progress-ring');\n if (ring) ring.style.opacity = '0';\n localeData.hint.classList.add('tooltip-expanded');\n setTimeout(() => {\n const longContent = localeData.hint.querySelector('.long-content');\n if (longContent) longContent.classList.add('show');\n }, 100);\n }\n}\n\nasync function tooltipShowDelegated(e) { // use event delegation to handle dynamically created elements\n if (e.target.dataset && e.target.dataset.hint) tooltipShow(e);\n}\n\nasync function tooltipHideDelegated(e) {\n if (e.target.dataset && e.target.dataset.hint) tooltipHide(e);\n}\n\nasync function tooltipShow(e) {\n if (localeData.expandTimeout) { // clear any existing expansion timeout\n clearTimeout(localeData.expandTimeout);\n localeData.expandTimeout = undefined;\n }\n\n localeData.hint.classList.remove('tooltip-expanded'); // remove expanded class and reset current element\n localeData.currentElement = e.target;\n\n if (e.target.dataset.hint) {\n const progressRing = ` // create progress ring SVG\n
\n \n \n \n \n
\n `;\n // set up the complete content structure from the start\n let content = `\n
\n ${e.target.textContent}\n ${e.target.dataset.longHint ? progressRing : ''}\n
\n
\n ${e.target.dataset.hint}\n `;\n if (e.target.dataset.longHint) content += `
${e.target.dataset.longHint}
`; // add long content if available, but keep it hidden\n if (e.target.dataset.reload) { // add reload notice if needed\n const reloadType = e.target.dataset.reload;\n let reloadText = '';\n if (reloadType === 'model') reloadText = 'Requires model reload';\n else if (reloadType === 'server') reloadText = 'Requires server restart';\n if (reloadText) {\n content += `\n
\n
\n ${reloadText}\n
\n `;\n }\n }\n\n localeData.hint.innerHTML = content;\n localeData.hint.classList.add('tooltip-show');\n\n if (e.clientX > window.innerWidth / 2) localeData.hint.classList.add('tooltip-left');\n else localeData.hint.classList.remove('tooltip-left');\n\n if (e.target.dataset.longHint) { // set up expansion timer if long hint is available\n const ring = localeData.hint.querySelector('.tooltip-progress-ring'); // start progress ring animation\n const ringProgress = localeData.hint.querySelector('.ring-progress');\n if (ring && ringProgress) {\n setTimeout(() => {\n ring.classList.add('active');\n ringProgress.classList.add('animate');\n }, 100);\n }\n localeData.expandTimeout = setTimeout(() => expandTooltip(e.target, e.target.dataset.longHint), 3000);\n }\n }\n}\n\nasync function tooltipHide(e) {\n if (localeData.expandTimeout) {\n clearTimeout(localeData.expandTimeout);\n localeData.expandTimeout = undefined;\n }\n localeData.hint.classList.remove('tooltip-show', 'tooltip-expanded');\n localeData.currentElement = null;\n}\n\nasync function replaceButtonText(el) {\n // https://www.nerdfonts.com/cheat-sheet\n // use unicode of icon with format nf-md-_circle\n const textIcons = {\n Generate: '\\uf144',\n Enqueue: '\\udb81\\udc17',\n Stop: '\\udb81\\ude66',\n Skip: '\\udb81\\ude61',\n Pause: '\\udb80\\udfe5',\n Restore: '\\udb82\\udd9b',\n Clear: '\\udb80\\udd59',\n Networks: '\\uf261',\n };\n if (textIcons[el.innerText]) {\n el.classList.add('button-icon');\n el.innerText = textIcons[el.innerText];\n }\n}\n\nasync function getLocaleData(desiredLocale = null) {\n if (desiredLocale) desiredLocale = desiredLocale.split(':')[0];\n if (desiredLocale === 'Auto') {\n try {\n localeData.locale = navigator.languages && navigator.languages.length ? navigator.languages[0] : navigator.language;\n localeData.locale = localeData.locale.split('-')[0];\n localeData.prev = localeData.locale;\n } catch (e) {\n localeData.locale = 'en';\n log('getLocale', e);\n }\n } else {\n localeData.locale = desiredLocale || 'en';\n localeData.prev = localeData.locale;\n }\n log('getLocale', desiredLocale, localeData.locale);\n // primary\n let json: any = {};\n try {\n let res = await fetch(`${window.subpath}/file=ui/locale/locale_${localeData.locale}.json`);\n if (!res || !res.ok) {\n localeData.locale = 'en';\n res = await fetch(`${window.subpath}/file=ui/locale/locale_${localeData.locale}.json`);\n }\n json = await res.json();\n } catch { /**/ }\n\n try {\n const res = await fetch(`${window.subpath}/file=ui/locale/override_${localeData.locale}.json`);\n if (res && res.ok) json.override = await res.json();\n } catch { /**/ }\n\n return json;\n}\n\nasync function replaceTextContent(el, text) {\n if (el.children.length === 1 && el.firstElementChild.classList.contains('mask-icon')) return;\n if (el.querySelector('span')) el = el.querySelector('span');\n if (el.querySelector('div')) el = el.querySelector('div');\n if (el.classList.contains('mask-icon')) return; // skip icon buttons\n if (el.dataset.selector) { // replace on rehosted child if exists\n el = el.firstElementChild || el.querySelector(el.dataset.selector);\n replaceTextContent(el, text);\n return;\n }\n el.textContent = text;\n}\n\nasync function setHint(el, entry) {\n if (localeData.type === 1) {\n el.title = entry.hint;\n } else if (localeData.type === 2) {\n el.dataset.hint = entry.hint;\n if (entry.longHint && entry.longHint.length > 0) el.dataset.longHint = entry.longHint;\n if (entry.reload && entry.reload.length > 0) el.dataset.reload = entry.reload;\n } else {\n // tooltips disabled\n }\n}\n\nfunction createLocaleJSON() {\n const excludeText = ['\u25BC']; // add any common non-label elements to exclude\n const ecxcludeIds = ['logo_nav']; // add any specific element IDs to exclude\n const elements = [...new Set([\n ...Array.from(gradioApp().querySelectorAll('button')),\n ...Array.from(gradioApp().querySelectorAll('h1')),\n ...Array.from(gradioApp().querySelectorAll('h2')),\n ...Array.from(gradioApp().querySelectorAll('h3')),\n ...Array.from(gradioApp().querySelectorAll('.hint')),\n ...Array.from(gradioApp().querySelectorAll('label > span')),\n ...Array.from(gradioApp().querySelectorAll('.label-wrap > span')),\n ...Array.from(gradioApp().querySelectorAll('span[data-testid=\"block-info\"]')),\n ])];\n const json = {};\n const allSeen = {};\n for (const el of elements) {\n const label = el.textContent.trim();\n if (!label || label.length < 1 || label.length > 1024) continue; // likely not UI element\n if (excludeText.includes(label)) continue; // skip common non-label elements\n if (ecxcludeIds.includes(el.id)) continue; // skip specific element IDs\n\n let hint = el.dataset.hint || '';\n if (hint.toLowerCase() === label.toLowerCase()) hint = ''; // skip if hint is same as label\n if (Object.keys(allSeen).includes(label.toLowerCase())) {\n if (hint.length === 0 || allSeen[label.toLowerCase()] === hint) continue; // seen this label and hint is empty or same as before\n hint = allSeen[label.toLowerCase()]; // use existing hint for this label\n }\n allSeen[label.toLowerCase()] = hint; // track seen labels\n\n let section = label[0].toLowerCase();\n if (section >= '0' && section <= '9') section = '0';\n if ((section < 'a' || section > 'z') && section !== '0') section = '_';\n\n let ui = el.closest('.group-extension')\n || el.closest('.group-scripts')\n || el.closest('.main-tab')\n || el.closest('.settings_section')\n || el.closest('.tabitem')\n || 'other';\n ui = ui?.id?.replace('_tabitem_parent', '').replace('_section_row', '');\n if (ui?.includes('_script')) ui = ui?.split('_').slice(1).join('_').split(':')[0];\n\n if (!json[section]) json[section] = [];\n const entry = { id: el.id || '', label, localized: '', hint, ui };\n json[section].push(entry); // add new entry\n }\n const sorted = Object.keys(json).sort().reduce((obj, key) => {\n obj[key] = json[key];\n return obj;\n }, {});\n console.log('localeJSON', sorted);\n}\n\nexport async function setHints() {\n let json: any;\n let overrideData: any[] = [];\n if (localeData.finished) return;\n if (Object.keys(opts).length === 0) return;\n const elements = [...new Set([\n ...Array.from(gradioApp().querySelectorAll('button')),\n ...Array.from(gradioApp().querySelectorAll('h2')),\n ...Array.from(gradioApp().querySelectorAll('label > span')),\n ...Array.from(gradioApp().querySelectorAll('.label-wrap > span')),\n ...Array.from(gradioApp().querySelectorAll('span[data-testid=\"block-info\"]')), // radio/checkboxgroup titles render as a bare block-info span, not under a label\n ])];\n if (elements.length === 0) return;\n if (localeData.data.length === 0) {\n json = await getLocaleData(window.opts.ui_locale);\n overrideData = Object.values(json.override || {}).flat().filter((e: any) => e.hint.length > 0);\n const jsonData = Object.values(json).flat().filter((e: any) => e.hint.length > 0);\n localeData.data = [...overrideData, ...jsonData];\n }\n if (!localeData.hint) tooltipCreate();\n let localized = 0;\n let hints = 0;\n const t0 = performance.now();\n\n for (const el of elements) {\n // localize elements text\n let found;\n if (el.id) found = localeData.data.find((l) => l.id && (l.id === el.id || el.id.endsWith(l.id))); // prefer id match for disambiguation\n if (!found) {\n if (el.dataset.original) found = localeData.data.find((l) => l.label.toLowerCase().trim() === el.dataset.original.toLowerCase().trim());\n else found = localeData.data.find((l) => l.label.toLowerCase().trim() === el.textContent.toLowerCase().trim());\n }\n if (found?.localized?.length > 0) {\n if (!el.dataset.original) el.dataset.original = el.textContent;\n replaceTextContent(el, found.localized);\n localized++;\n } else if (found?.label && !localeData.initial && (localeData.locale === 'en')) { // reset to english\n replaceTextContent(el, found.label);\n }\n // set hints\n if (found?.hint?.length > 0) {\n hints++;\n setHint(el, found);\n }\n }\n localeData.finished = true;\n localeData.initial = false;\n const t1 = performance.now();\n timer('setHints', t1 - t0);\n // localeData.btn.style.backgroundColor = localeData.locale !== 'en' ? 'var(--primary-500)' : '';\n log('touchDevice', isTouchDevice);\n log('setHints', { type: localeData.type, locale: localeData.locale, elements: elements.length, localized, hints, data: localeData.data.length, override: overrideData.length, time: Math.round(t1 - t0) });\n // sortUIElements();\n}\n\n// Apply hints to a single element immediately\nasync function applyHintToElement(el) {\n if (!localeData.data || localeData.data.length === 0) return;\n // if (!el.textContent) return;\n\n // check if element matches our selector criteria\n const isValidElement = el.tagName === 'BUTTON'\n || el.tagName === 'H2'\n || el.classList.contains('hint')\n || (el.tagName === 'SPAN' && (el.parentElement?.tagName === 'LABEL' || el.parentElement?.classList.contains('label-wrap') || el.dataset.testid === 'block-info'));\n if (!isValidElement) return;\n\n let found; // find matching hint data - prefer id match for disambiguation\n if (el.id) found = localeData.data.find((l) => l.id && (l.id === el.id || el.id.endsWith(l.id)));\n if (!found) {\n if (el.dataset.original) found = localeData.data.find((l) => l.label.toLowerCase().trim() === el.dataset.original.toLowerCase().trim());\n else found = localeData.data.find((l) => l.label.toLowerCase().trim() === el.textContent.toLowerCase().trim());\n }\n\n if (el.textContent && el.textContent.length > 0 && found?.localized?.length > 0) { // apply localization if found\n if (!el.dataset.original) el.dataset.original = el.textContent;\n replaceTextContent(el, found.localized);\n }\n\n if (found?.hint?.length > 0) setHint(el, found); // apply hint if found\n}\n\n// Initialize MutationObserver for immediate hint application\nfunction initializeDOMObserver() {\n if (hintsObserver) hintsObserver.disconnect();\n\n hintsObserver = new MutationObserver((mutations) => {\n // Process added nodes immediately\n for (const mutation of mutations) {\n if (mutation.type === 'childList') {\n for (const node of mutation.addedNodes) {\n if (node.nodeType === Node.ELEMENT_NODE) {\n // Apply hints to the node itself\n applyHintToElement(node);\n\n // Apply hints to all relevant children\n const elements = [\n ...Array.from(node.querySelectorAll('button')),\n ...Array.from(gradioApp().querySelectorAll('h1')),\n ...Array.from(gradioApp().querySelectorAll('h2')),\n ...Array.from(gradioApp().querySelectorAll('h3')),\n ...Array.from(gradioApp().querySelectorAll('.hint')),\n ...Array.from(node.querySelectorAll('label > span')),\n ...Array.from(node.querySelectorAll('.label-wrap > span')),\n ...Array.from(node.querySelectorAll('span[data-testid=\"block-info\"]')),\n ];\n\n // Include the node itself if it matches\n if (node.matches && (\n node.matches('button')\n || node.matches('h1')\n || node.matches('h2')\n || node.matches('h3')\n || node.matches('label > span')\n || node.matches('.hint')\n || node.matches('.label-wrap > span')\n || node.matches('span[data-testid=\"block-info\"]')\n )) {\n elements.push(node);\n }\n\n // Apply hints immediately to all found elements\n elements.forEach((el) => applyHintToElement(el));\n }\n }\n }\n }\n });\n\n // Start observing the entire gradio app for changes\n const targetNode = gradioApp();\n if (targetNode) {\n hintsObserver.observe(targetNode, {\n childList: true,\n subtree: true,\n });\n }\n}\n\nexport function disconnectHintsObserver() {\n if (hintsObserver) {\n hintsObserver.disconnect();\n hintsObserver = null;\n }\n}\n\n// Export for external use if needed\nconst forceReapplyHints = () => setHints();\n", "import { gradioApp, getUICurrentTabContent } from './script';\nimport { log } from './logger';\nimport { authFetch } from './authWrap';\nimport { quickApplyStyle, quickSaveStyle } from './extraNetworks';\n\ninterface ContextMenuItem {\n id: string;\n name: string;\n func: () => void;\n primary: boolean;\n}\n\nconst contextMenuInit = () => {\n let eventListenerApplied = false;\n const menuSpecs = new Map();\n\n const uid = () => Date.now().toString(36) + Math.random().toString(36).substring(2);\n\n function showContextMenu(event: MouseEvent, _element: Element, menuEntries: ContextMenuItem[]): void {\n const posx = event.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;\n const posy = event.clientY + document.body.scrollTop + document.documentElement.scrollTop;\n const oldMenu = gradioApp().querySelector('#context-menu');\n if (oldMenu) oldMenu.remove();\n const contextMenu = document.createElement('nav');\n contextMenu.id = 'context-menu';\n contextMenu.style.top = `${posy}px`;\n contextMenu.style.left = `${posx}px`;\n const contextMenuList = document.createElement('ul');\n contextMenuList.className = 'context-menu-items';\n contextMenu.append(contextMenuList);\n menuEntries.forEach((entry) => {\n const contextMenuEntry = document.createElement('a');\n contextMenuEntry.innerHTML = entry.name;\n contextMenuEntry.addEventListener('click', () => entry.func());\n contextMenuList.append(contextMenuEntry);\n });\n gradioApp().appendChild(contextMenu);\n const menuWidth = contextMenu.offsetWidth + 4;\n const menuHeight = contextMenu.offsetHeight + 4;\n const windowWidth = window.innerWidth;\n const windowHeight = window.innerHeight;\n if ((windowWidth - posx) < menuWidth) contextMenu.style.left = `${windowWidth - menuWidth}px`;\n if ((windowHeight - posy) < menuHeight) contextMenu.style.top = `${windowHeight - menuHeight}px`;\n }\n\n function appendContextMenuOption(targetElementSelector: string, entryName: string, entryFunction: () => void, primary = false): string {\n let currentItems = menuSpecs.get(targetElementSelector);\n if (!currentItems) {\n currentItems = [];\n menuSpecs.set(targetElementSelector, currentItems);\n }\n const newItem = {\n id: `${targetElementSelector}_${uid()}`,\n name: entryName,\n func: entryFunction,\n primary,\n // isNew: true,\n };\n currentItems.push(newItem);\n return newItem.id;\n }\n\n function removeContextMenuOption(id: string): void {\n menuSpecs.forEach((v, k) => {\n let index = -1;\n v.forEach((e, ei) => {\n if (e.id === id) { index = ei; }\n });\n if (index >= 0) v.splice(index, 1);\n });\n }\n\n window.appendContextMenuOption = appendContextMenuOption;\n window.removeContextMenuOption = removeContextMenuOption;\n\n async function addContextMenuEventListener(): Promise {\n if (eventListenerApplied) return;\n log('initContextMenu');\n gradioApp().addEventListener('click', (e: Event) => {\n const mouseEvent = e as MouseEvent;\n if (!mouseEvent.isTrusted) return;\n const oldMenu = gradioApp().querySelector('#context-menu');\n if (oldMenu) oldMenu.remove();\n menuSpecs.forEach((v, k) => {\n const items = v.filter((item) => item.primary);\n const target = mouseEvent.target as Element | null;\n if (!target) return;\n const matched = target.closest(k);\n if (items.length > 0 && matched) {\n showContextMenu(mouseEvent, matched, items);\n mouseEvent.preventDefault();\n }\n });\n });\n gradioApp().addEventListener('contextmenu', (e: Event) => {\n const mouseEvent = e as MouseEvent;\n const oldMenu = gradioApp().querySelector('#context-menu');\n if (oldMenu) oldMenu.remove();\n menuSpecs.forEach((v, k) => {\n const items = v.filter((item) => !item.primary);\n const target = mouseEvent.target as Element | null;\n if (!target) return;\n const matched = target.closest(k);\n if (items.length > 0 && matched) {\n showContextMenu(mouseEvent, matched, items);\n mouseEvent.preventDefault();\n }\n });\n });\n eventListenerApplied = true;\n }\n return [appendContextMenuOption, removeContextMenuOption, addContextMenuEventListener];\n};\n\nconst initContextResponse = contextMenuInit();\nconst appendContextMenuOption = initContextResponse[0];\nconst removeContextMenuOption = initContextResponse[1];\nconst addContextMenuEventListener = initContextResponse[2] as () => void;\n\nlet generateOnRepeatInterval: ReturnType | null = null;\n\nexport const generateForever = (genbuttonid: string): void => {\n if (generateOnRepeatInterval) {\n log('generateForever: cancel');\n clearInterval(generateOnRepeatInterval);\n generateOnRepeatInterval = null;\n } else {\n const genbutton = gradioApp().querySelector(genbuttonid);\n if (!(genbutton instanceof HTMLElement)) return;\n const isBusy = () => {\n let busy = document.getElementById('progressbar')?.style.display === 'block';\n if (!busy) {\n // Also check in Modern UI\n const outerButton = genbutton.parentElement.closest('button');\n busy = outerButton?.classList.contains('generate') && outerButton?.classList.contains('active');\n }\n return busy;\n };\n log('generateForever: start');\n if (!isBusy()) genbutton.click();\n generateOnRepeatInterval = setInterval(() => {\n if (!isBusy()) genbutton.click();\n }, 500);\n }\n};\nwindow.generateForever = generateForever;\n\nconst reprocessClick = (tabId: string, state: string): void => {\n const btn = document.getElementById(`${tabId}_${state}`);\n window.submit_state = state;\n if (btn) btn.click();\n};\n\nconst getStatus = async () => {\n const headers = new Headers();\n const body = JSON.stringify({ id_task: -1, id_live_preview: false });\n headers.set('Content-Type', 'application/json');\n const tab = getUICurrentTabContent()?.id.replace('tab_', '') || '';\n const el = gradioApp().querySelector(`#html_log_${tab} .performance p`);\n\n let res;\n let data;\n res = await fetch('./internal/progress', { method: 'POST', headers, body });\n if (res?.ok) {\n data = await res.json();\n log('progressInternal:', data);\n if (el) el.innerText += `\\nProgress internal:\\n${JSON.stringify(data, null, 2)}`;\n }\n res = await authFetch('./sdapi/v1/progress?skip_current_image=true', { method: 'GET', headers });\n if (res?.ok) {\n data = await res.json();\n log('progressAPI:', data);\n if (el) el.innerText += `\\nProgress API:\\n${JSON.stringify(data, null, 2)}`;\n }\n};\n\nexport async function initContextMenu() {\n for (const tab of ['txt2img', 'img2img', 'control', 'video']) {\n appendContextMenuOption(`#${tab}_generate`, 'Get server status', getStatus);\n appendContextMenuOption(`#${tab}_generate`, 'Copy prompt to clipboard', () => navigator.clipboard.writeText(document.querySelector(`#${tab}_prompt > label > textarea`).value));\n appendContextMenuOption(`#${tab}_generate`, 'Generate forever', () => generateForever(`#${tab}_generate`));\n appendContextMenuOption(`#${tab}_generate`, 'Apply selected style', quickApplyStyle);\n appendContextMenuOption(`#${tab}_generate`, 'Quick save style', quickSaveStyle);\n appendContextMenuOption(`#${tab}_reprocess`, 'Decode full quality', () => reprocessClick(tab, 'reprocess_decode'), true);\n appendContextMenuOption(`#${tab}_reprocess`, 'Refine & HiRes pass', () => reprocessClick(tab, 'reprocess_refine'), true);\n appendContextMenuOption(`#${tab}_reprocess`, 'Detailer pass', () => reprocessClick(tab, 'reprocess_detail'), true);\n }\n // Right-click send-to-control button for prompt/params-only transfer.\n for (const tab of ['gallery', 'txt2img', 'img2img', 'extras']) {\n appendContextMenuOption(`#${tab}_tabitem #control_tab`, 'Transfer only prompt to Images tab', () => {\n document.querySelector(`#image_buttons_${tab} #control_tab_prompt`)?.click();\n document.getElementById('control_nav')?.click();\n });\n appendContextMenuOption(`#${tab}_tabitem #control_tab`, 'Transfer all parameters to Images tab', () => {\n document.querySelector(`#image_buttons_${tab} #control_tab_params`)?.click();\n document.getElementById('control_nav')?.click();\n });\n }\n addContextMenuEventListener();\n}\n", "import { gradioApp } from './script';\n\nexport function uiOpenSubmenus() {\n const accordions = Array.from(gradioApp().querySelectorAll('.gradio-accordion'));\n const states: Record = {};\n accordions.forEach((el) => {\n const labelEl = el.querySelector('.label-wrap > span:not(.icon)');\n const name = labelEl instanceof HTMLElement ? labelEl.innerText.trim() : '';\n if (!name) return;\n const children = Array.from(el.childNodes);\n const open = children.filter((c) => c instanceof HTMLElement && c.style.display === 'block');\n if (states[name] === undefined) states[name] = open.length > 0;\n });\n return states;\n}\n\nexport async function getUIDefaults() {\n const btn = gradioApp().getElementById('ui_defaults_view');\n if (!btn) return;\n const intersectionObserver = new IntersectionObserver((entries) => {\n if (entries[0].intersectionRatio <= 0) { /* Pass */ }\n if (entries[0].intersectionRatio > 0) btn.click();\n });\n intersectionObserver.observe(btn); // monitor visibility of tab\n}\n\nwindow.uiOpenSubmenus = uiOpenSubmenus;\n", "import { error, log, xhrPost } from './logger';\nimport { authFetch } from './authWrap';\nimport { timer } from './timers';\n\nexport const appStartTime = performance.now();\nlet monitorLogActive = false;\n\nasync function preloadImages(): Promise {\n const dark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;\n const imagePromises: Promise[] = [];\n const num = Math.floor(9.99 * Math.random());\n const imageUrls = [\n `file=ui/assets/logo-bg-${dark ? 'dark' : 'light'}.jpg`,\n `file=ui/assets/logo-bg-${num}.jpg`,\n ];\n for (const url of imageUrls) {\n const img = new Image();\n const promise = new Promise((resolve, reject) => {\n img.onload = () => resolve();\n img.onerror = () => reject(new Error(`failed to preload image: ${url}`));\n });\n img.src = url;\n imagePromises.push(promise);\n }\n try {\n await Promise.all(imagePromises);\n return true;\n } catch (err) {\n error(`preloadImages: ${err}`);\n return false;\n }\n}\n\nfunction joinArgs(messages: unknown[]): string {\n let output = '';\n for (let i = 0; i < messages.length; i++) {\n let arg = messages[i];\n if (arg === undefined) arg = 'undefined';\n if (arg === null) arg = 'null';\n output += ' ';\n if (typeof arg === 'object') output += JSON.stringify(arg).replace(/[\"]+/g, '');\n else output += arg;\n }\n return output;\n}\n\nfunction monitorLog(): void {\n if (window.logBufferDirty) {\n window.logBufferDirty = false;\n const maxLines = 100; // print last n logs from ring buffer to splash-log\n const lines: string[] = [];\n // print last n logs from ring buffer in time order\n for (let i = Math.max(0, window.logRingBuffer.length - maxLines); i < window.logRingBuffer.length; i++) {\n const logEntry = window.logRingBuffer[i];\n let color = 'white';\n if (logEntry.type === 'error') color = 'palevioletred';\n else if (logEntry.type === 'debug') color = 'gray';\n const html = `
${logEntry.ts}   ${joinArgs(logEntry.msg)}
`;\n lines.push(html);\n }\n const splashLogEl = document.getElementById('splashLog');\n if (splashLogEl) splashLogEl.innerHTML = lines.join('');\n }\n if (monitorLogActive) setTimeout(monitorLog, 250);\n}\n\nexport async function removeSplash() {\n const splash = document.getElementById('splash');\n if (splash) splash.remove();\n log('removeSplash');\n const t = Math.round(performance.now() - appStartTime);\n log('startupTime', t);\n timer('splashVisible', t);\n xhrPost(`${window.api}/log`, { message: `ready time=${t}` });\n monitorLogActive = false;\n}\n\nasync function createSplash() {\n const dark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;\n log('createSplash', { theme: dark ? 'dark' : 'light' });\n const num = Math.floor(9.99 * Math.random());\n const splash = `\n
\n
\n
\n
\n
`;\n document.body.insertAdjacentHTML('beforeend', splash);\n const ok = await preloadImages();\n if (!ok) {\n removeSplash();\n return;\n }\n const imgEl = `
`;\n const splashEl = document.getElementById('splash');\n if (splashEl) splashEl.insertAdjacentHTML('afterbegin', imgEl);\n\n monitorLogActive = true;\n monitorLog();\n\n await authFetch(`${window.api}/motd`)\n .then((res) => res.text())\n .then((text) => {\n const clean = text.replace(/[\"]+/g, '');\n log('getMOTD', clean);\n const motdEl = document.getElementById('motd');\n if (motdEl) motdEl.innerHTML = clean;\n })\n .catch((err) => error(`getMOTD: ${err}`));\n\n log('loadGradioUi');\n}\n\nwindow.onload = createSplash;\n", "import { log } from './logger';\n\nexport function addLegacyNotice() {\n log('legacyNotice');\n const notice = document.createElement('div');\n notice.id = 'legacy-notice';\n notice.className = 'legacy-standard';\n notice.textContent = 'Legacy';\n notice.title = 'Standard UI is a legacy interface that is no longer maintained and will be removed in the future. Please switch to ModernUI for best experience.';\n document.body.appendChild(notice);\n}\n", "import { initChangelog } from './changelog';\nimport { setupControlUI } from './control';\nimport { initiGenerationParams } from './generationParams';\nimport { initDragDrop } from './imageParams';\nimport { initAccordions } from './inputAccordion';\nimport { initIndexDB } from './indexdb';\nimport { initLogMonitor } from './logMonitor';\nimport { monitorConnection } from './monitor';\nimport { setRefreshInterval } from './progressBar';\nimport { initPromptChecker } from './promptChecker';\nimport { initModels, initSettings } from './settings';\nimport { initGallery } from './gallery';\nimport { initImageViewer } from './imageViewer';\nimport { reconnectUI } from './ui';\nimport { setupExtraNetworks, showNetworks, applyStyles } from './extraNetworks';\nimport { initAutocomplete } from './autocomplete';\nimport { setHints, disconnectHintsObserver } from './setHints';\nimport { initContextMenu } from './contextMenus';\nimport { executeCallbacks, onUiLoaded, onUiReady, sleep, uiReadyCallbacks, initTableSorter } from './script';\nimport { timer, logTimers } from './timers';\nimport { getUIDefaults } from './uiConfig';\nimport { log } from './logger';\nimport { appStartTime, removeSplash } from './loader';\nimport { addLegacyNotice } from './legacy';\n\nwindow.api = '/sdapi/v1';\nwindow.subpath = '';\n\nconst startupPromises: Promise[] = [];\nlet ok = false;\n\nasync function waitForOpts() {\n // make sure all of the ui is ready and options are loaded\n const t0 = performance.now();\n let t1 = performance.now();\n while (true) {\n if (t1 - t0 > 120000) {\n log('waitForOpts timeout');\n break;\n }\n if (window.opts && Object.keys(window.opts).length > 0) {\n ok = window.opts.theme_type === 'Modern' ? 'uiux_separator_appearance' in window.opts : true;\n if (ok) {\n log('waitForOpts', Math.round(t1 - t0));\n timer('waitForOpts', t1 - t0);\n break;\n }\n }\n await sleep(100);\n t1 = performance.now();\n }\n}\n\nasync function postStartup() {\n log('postStartup');\n disconnectHintsObserver();\n logTimers();\n}\n\nasync function initStartup() {\n const t0 = performance.now();\n log('initGradio', Math.round(t0 - appStartTime));\n timer('initGradio', t0 - appStartTime);\n log('initUi');\n if (window.setupLogger) await window.setupLogger();\n\n // all items here are non-blocking async calls\n\n startupPromises.push(initModels());\n startupPromises.push(getUIDefaults());\n startupPromises.push(initPromptChecker());\n startupPromises.push(initContextMenu());\n startupPromises.push(initDragDrop());\n startupPromises.push(Promise.resolve(initAccordions()));\n startupPromises.push(Promise.resolve(initSettings()));\n startupPromises.push(Promise.resolve(initImageViewer()));\n startupPromises.push(Promise.resolve(initGallery()));\n startupPromises.push(Promise.resolve(initiGenerationParams()));\n startupPromises.push(Promise.resolve(initChangelog()));\n startupPromises.push(Promise.resolve(setupControlUI()));\n\n // reconnect server session\n await reconnectUI();\n await waitForOpts();\n\n log('mountURL', window.opts.subpath);\n if (window.opts.subpath?.length > 0) {\n window.subpath = window.opts.subpath;\n window.api = `${window.subpath}/sdapi/v1`;\n }\n\n startupPromises.push(initLogMonitor());\n\n executeCallbacks(uiReadyCallbacks);\n\n // optionally wait for modern ui\n if (window.waitForUiReady) await window.waitForUiReady();\n\n // post startup tasks that may take longer but are not critical\n startupPromises.push(Promise.resolve(initGallery()));\n startupPromises.push(Promise.resolve(setRefreshInterval()));\n startupPromises.push(Promise.resolve(setupExtraNetworks()));\n startupPromises.push(Promise.resolve(initAutocomplete()));\n startupPromises.push(Promise.resolve(monitorConnection()));\n startupPromises.push(Promise.resolve(showNetworks()));\n startupPromises.push(Promise.resolve(setHints()));\n startupPromises.push(Promise.resolve(applyStyles()));\n startupPromises.push(Promise.resolve(initIndexDB()));\n startupPromises.push(Promise.resolve(initTableSorter()));\n\n if (window.opts.theme_type !== 'Modern') addLegacyNotice();\n\n const t1 = performance.now();\n log('initStartup', Math.round(1000 * (t1 - t0) / 1000000));\n\n removeSplash();\n\n await Promise.all(startupPromises);\n const t2 = performance.now();\n log('initComplete', Math.round(1000 * (t2 - t0) / 1000000));\n postStartup();\n}\n\nonUiLoaded(initStartup);\nonUiReady(() => log('uiReady'));\n\n// onAfterUiUpdate(() => log('evt onAfterUiUpdate'));\n// onUiLoaded(() => log('evt onUiLoaded'));\n// onOptionsChanged(() => log('evt onOptionsChanged'));\n// onUiTabChange(() => log('evt onUiTabChange'));\n// onUiUpdate(() => log('evt onUiUpdate'));\n", "import { randomId } from './progressBar';\n\nimport { log } from './logger';\nimport { gradioApp } from './script';\nimport { restartReload, updateInput } from './ui';\n\nexport function extensions_apply(_extensionsDisabledList: unknown, _extensionsUpdateList: unknown, disableAll: unknown): [string, string, unknown] {\n const disable = [];\n const update = [];\n gradioApp().querySelectorAll('#extensions input[type=\"checkbox\"]').forEach((x) => {\n if (!(x instanceof HTMLInputElement)) return;\n if (x.name.startsWith('enable_') && !x.checked) disable.push(x.name.substring(7));\n if (x.name.startsWith('update_') && x.checked) update.push(x.name.substring(7));\n });\n restartReload();\n log('Extensions apply:', { disable, update });\n return [JSON.stringify(disable), JSON.stringify(update), disableAll];\n}\n\nexport function extensions_check(_info: unknown, _extensionsDisabledList: unknown, searchText: unknown, sortColumn: unknown): [string, string, unknown, unknown] {\n const disable = [];\n gradioApp().querySelectorAll('#extensions input[type=\"checkbox\"]').forEach((x) => {\n if (!(x instanceof HTMLInputElement)) return;\n if (x.name.startsWith('enable_') && !x.checked) disable.push(x.name.substring(7));\n });\n const id = randomId();\n log('Extensions check:', { disable });\n return [id, JSON.stringify(disable), searchText, sortColumn];\n}\n\nexport function install_extension(button: HTMLButtonElement | HTMLInputElement, url: string): void {\n button.disabled = true;\n button.value = 'Installing...';\n button.innerHTML = 'installing';\n const textarea = gradioApp().querySelector('#extension_to_install textarea');\n if (!(textarea instanceof HTMLTextAreaElement)) return;\n textarea.value = url;\n updateInput(textarea);\n log('Extension install:', { url });\n const installBtn = gradioApp().querySelector('#install_extension_button');\n if (installBtn instanceof HTMLElement) installBtn.click();\n}\n\nexport function uninstall_extension(button: HTMLButtonElement | HTMLInputElement, url: string): void {\n button.disabled = true;\n button.value = 'Uninstalling...';\n button.innerHTML = 'uninstalling';\n const textarea = gradioApp().querySelector('#extension_to_install textarea');\n if (!(textarea instanceof HTMLTextAreaElement)) return;\n textarea.value = url;\n updateInput(textarea);\n log('Extension uninstall:', { url });\n const uninstallBtn = gradioApp().querySelector('#uninstall_extension_button');\n if (uninstallBtn instanceof HTMLElement) uninstallBtn.click();\n}\n\nexport function update_extension(button: HTMLButtonElement | HTMLInputElement, url: string): void {\n button.value = 'Updating...';\n button.innerHTML = 'updating';\n const textarea = gradioApp().querySelector('#extension_to_install textarea');\n if (!(textarea instanceof HTMLTextAreaElement)) return;\n textarea.value = url;\n updateInput(textarea);\n log('Extension update:', { url });\n const updateBtn = gradioApp().querySelector('#update_extension_button');\n if (updateBtn instanceof HTMLInputElement) updateBtn.click();\n}\n\nwindow.extensions_apply = extensions_apply;\nwindow.extensions_check = extensions_check;\nwindow.uninstall_extension = uninstall_extension;\nwindow.install_extension = install_extension;\nwindow.update_extension = update_extension;\n", "import { log } from './logger';\nimport { gradioApp, uiElementIsVisible, uiElementInSight } from './script';\n\ntype PromptDropTarget = EventTarget & {\n placeholder?: string;\n closest: (selector: string) => Element | null;\n};\n\nfunction isValidImageList(files: FileList | null | undefined): files is FileList {\n return files && files?.length === 1 && ['image/png', 'image/gif', 'image/jpeg'].includes(files[0].type);\n}\n\nfunction dropReplaceImage(imgWrap: Element, files: FileList): void {\n log('dropReplaceImage', imgWrap, files);\n if (!isValidImageList(files)) return;\n const tmpFile = files[0];\n imgWrap.querySelector('.modify-upload button + button, .touch-none + div button + button')?.click();\n const callback = () => {\n const fileInput = imgWrap.querySelector('input[type=\"file\"]');\n if (fileInput instanceof HTMLInputElement) {\n if (files.length === 0) {\n const dt = new DataTransfer();\n dt.items.add(tmpFile);\n fileInput.files = dt.files;\n } else {\n fileInput.files = files;\n }\n fileInput.dispatchEvent(new Event('change'));\n }\n };\n\n if (imgWrap.closest('#pnginfo_image')) {\n const oldFetch = window.fetch;\n window.fetch = async (input: RequestInfo | URL, options?: RequestInit) => {\n const response = await oldFetch(input, options);\n if (input === 'api/predict/') {\n const content = await response.text();\n window.fetch = oldFetch;\n window.requestAnimationFrame(() => callback());\n return new Response(content, {\n status: response.status,\n statusText: response.statusText,\n headers: response.headers,\n });\n }\n return response;\n };\n } else {\n window.requestAnimationFrame(() => callback());\n }\n}\n\nwindow.document.addEventListener('dragover', (e) => {\n const target = e.composedPath()[0] as PromptDropTarget;\n const imgWrap = target.closest('[data-testid=\"image\"]');\n if (!imgWrap && target.placeholder && target.placeholder.indexOf('Prompt') === -1) return;\n if ((e.dataTransfer?.files?.length || 0) > 0) {\n e.stopPropagation();\n e.preventDefault();\n e.dataTransfer.dropEffect = 'copy';\n }\n});\n\nwindow.document.addEventListener('drop', (e) => {\n const target = e.composedPath()[0] as PromptDropTarget;\n log('dropEvent', e, target);\n if (!target.placeholder) return;\n if (target.placeholder.indexOf('Prompt') === -1) return;\n const imgWrap = target.closest('[data-testid=\"image\"]');\n if (!imgWrap) return;\n if ((e.dataTransfer?.files?.length || 0) > 0) {\n e.stopPropagation();\n e.preventDefault();\n dropReplaceImage(imgWrap, e.dataTransfer.files);\n }\n});\n\nwindow.addEventListener('paste', (e) => {\n log('pasteEvent', e);\n const files = e.clipboardData?.files;\n if (!isValidImageList(files)) return;\n const visibleImageFields = [...gradioApp().querySelectorAll('[data-testid=\"image\"]')]\n .filter((el) => uiElementIsVisible(el))\n .sort((a, b) => Number(uiElementInSight(b)) - Number(uiElementInSight(a)));\n if (!visibleImageFields.length) return;\n const firstFreeImageField = visibleImageFields.filter((el) => el.querySelector('input[type=file]'))?.[0];\n dropReplaceImage(firstFreeImageField || visibleImageFields[visibleImageFields.length - 1], files);\n});\n", "import { gradioApp, onUiLoaded } from './script';\nimport { log, error } from './logger';\nimport { authFetch } from './authWrap';\n\ninterface CivitFile {\n url?: string;\n name?: string;\n type?: string;\n size?: number;\n}\n\ninterface CivitImage {\n url: string;\n}\n\ninterface CivitVersion {\n id: number;\n name?: string;\n base?: string;\n mtime: string;\n availability?: string;\n desc?: string;\n files: CivitFile[];\n images: CivitImage[];\n}\n\ninterface CivitModel {\n id: number;\n url: string;\n name?: string;\n type?: string;\n tags?: string[];\n nsfw?: boolean;\n level?: number;\n availability?: string;\n downloads?: number;\n creator?: string;\n desc?: string;\n versions: CivitVersion[];\n}\n\n// eslint-disable-next-line no-extend-native\nString.prototype.format = function format(this: string, args: Record): string {\n let thisString = '';\n for (let charPos = 0; charPos < this.length; charPos++) thisString += this[charPos];\n for (const key in args) {\n const stringKey = `{${key}}`;\n thisString = thisString.replace(new RegExp(stringKey, 'g'), String(args[key]));\n }\n return thisString;\n};\n\nlet selectedURL: string[] = [];\nlet selectedName: string[] = [];\nlet selectedType: string[] = [];\nlet selectedBase: string[] = [];\nlet selectedModelId: number[] = [];\nlet selectedVersionId: number[] = [];\n\nexport function clearModelDetails() {\n const el = gradioApp().getElementById('model-details') || gradioApp().getElementById('civitai_models_output') || gradioApp().getElementById('models_outcome');\n if (!el) return;\n el.innerHTML = '';\n}\nwindow.clearModelDetails = clearModelDetails;\n\nconst modelDetailsHTML = `\n
\n \"model\n \n \n \n \n \n \n \n \n \n \n \n
Name{name}
Type{type}
Tags
{tags}
NSFW{nsfw} | {level}
Availability{availability}
Downloads{downloads}
Author{creator}
Description
{desc}
Download
All variants
\n
\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n {versions}\n \n
VersionTypeBaseFileUpdatedSizeAvailabilityDescription
\n
\n`;\n\nconst modelVersionsHTML = `\n \n {url}\n {name}\n {type}\n {base}\n {file}\n {mtime}\n {size}\n {availability}\n
{desc}
\n \n`;\n\nexport async function modelCardClick(id) {\n log('modelCardClick id', id);\n const el = gradioApp().getElementById('model-details') || gradioApp().getElementById('civitai_models_output') || gradioApp().getElementById('models_outcome');\n if (!el) return;\n const res = await authFetch(`${window.api}/civitai?model_id=${encodeURI(id)}`);\n if (!res || res.status !== 200) {\n error(`modelCardClick: id=${id} status=${res ? res.status : 'unknown'}`);\n return;\n }\n const dataArray = await res.json();\n log('modelCardClick data', dataArray);\n if (!dataArray || dataArray.length === 0) return;\n const data: any = dataArray[0]; // assuming the first item is the one we want\n\n const versionsHTML = data.versions.map((v: CivitVersion) => modelVersionsHTML.format({\n url: `
\\udb80\\uddda
`,\n name: v.name || 'unknown',\n type: v.files[0]?.type || 'unknown',\n base: v.base || 'unknown',\n mtime: (new Date(v.mtime)).toLocaleDateString(),\n availability: v.availability || 'unknown',\n size: v.files[0]?.size ? `${(v.files[0].size / 1024 / 1024).toFixed(2)} MB` : 'unknown',\n file: `${v.files[0]?.name || 'unknown'}`,\n desc: v.desc || 'no description available',\n })).join('');\n const url = `${data.name || 'unknown'}`;\n const creator = `${data.creator || 'unknown'}`;\n const images = data.versions.map((v: CivitVersion) => v.images).flat().map((i: CivitImage) => i.url); // TODO image gallery\n const modelHTML = modelDetailsHTML.format({\n name: url,\n type: data.type || 'unknown',\n tags: data.tags?.join(', ') || '',\n nsfw: data.nsfw ? 'yes' : 'no',\n level: data.level?.toString() || '',\n availability: data.availability || 'unknown',\n downloads: data.downloads?.toString() || '',\n creator,\n desc: data.desc || 'no description available',\n image: images.length > 0 ? images[0] : '/sdapi/v1/network/thumb?filename=ui/assets/missing.png',\n versions: versionsHTML || '',\n });\n el.innerHTML = modelHTML;\n}\nwindow.modelCardClick = modelCardClick;\n\nexport function startCivitDownload(url, name, type, base, modelId, versionId) {\n log('startCivitDownload', { url, name, type, base, modelId, versionId });\n selectedURL = [url];\n selectedName = [name];\n selectedType = [type];\n selectedBase = [base || ''];\n selectedModelId = [modelId || 0];\n selectedVersionId = [versionId || 0];\n const civitDownloadBtn = gradioApp().getElementById('civitai_download_btn');\n if (civitDownloadBtn) civitDownloadBtn.click();\n}\nwindow.startCivitDownload = startCivitDownload;\n\nexport function startCivitAllDownload(evt) {\n log('startCivitAllDownload', evt);\n const table = gradioApp().getElementById('model-versions-table');\n if (!table) return;\n const versions = table.querySelectorAll('tr');\n selectedURL = [];\n selectedName = [];\n selectedType = [];\n selectedBase = [];\n selectedModelId = [];\n selectedVersionId = [];\n for (const version of versions) {\n const parsed = version.querySelector('td:nth-child(1) div')?.getAttribute('onclick')?.match(/startCivitDownload\\('([^']+)', '([^']+)', '([^']+)', '([^']*)', (\\d+), (\\d+)\\)/);\n if (!parsed || parsed.length < 7) continue;\n selectedURL.push(parsed[1]);\n selectedName.push(parsed[2]);\n selectedType.push(parsed[3]);\n selectedBase.push(parsed[4]);\n selectedModelId.push(parseInt(parsed[5], 10));\n selectedVersionId.push(parseInt(parsed[6], 10));\n }\n const civitDownloadBtn = gradioApp().getElementById('civitai_download_btn');\n if (civitDownloadBtn) civitDownloadBtn.click();\n}\nwindow.startCivitAllDownload = startCivitAllDownload;\n\nexport function downloadCivitModel(modelUrl, modelName, modelType, modelBase, mId, vId, modelPath, civitToken, innerHTML) {\n log('downloadCivitModel', { modelUrl, modelName, modelType, modelBase, mId, vId, modelPath, civitToken });\n const el = gradioApp().getElementById('civitai_models_output') || gradioApp().getElementById('models_outcome');\n const currentHTML = el?.innerHTML || '';\n return [selectedURL, selectedName, selectedType, selectedBase, selectedModelId, selectedVersionId, modelPath, civitToken, currentHTML];\n}\nwindow.downloadCivitModel = downloadCivitModel;\n\nlet civitMutualExcludeBound = false;\n\nexport function civitaiMutualExclude() {\n if (civitMutualExcludeBound) return;\n const searchEl = gradioApp().querySelector('#civit_search_text textarea');\n const tagEl = gradioApp().querySelector('#civit_search_tag textarea');\n if (!searchEl || !tagEl) return;\n civitMutualExcludeBound = true;\n searchEl.addEventListener('input', () => {\n tagEl.closest('.gradio-textbox')?.classList.toggle('disabled-look', !!searchEl.value.trim());\n });\n tagEl.addEventListener('input', () => {\n searchEl.closest('.gradio-textbox')?.classList.toggle('disabled-look', !!tagEl.value.trim());\n });\n}\n\nonUiLoaded(civitaiMutualExclude);\n", "import { log } from './logger';\n\ntype GuiderLike = string | { label?: string };\n\nconst guiders: Record = {\n None: '',\n 'LSC: LayerSkipConfig': 'https://github.com/huggingface/diffusers/blob/041501aea92919c9c7f36e189fc9cf7d865ebb96/src/diffusers/hooks/layer_skip.py#L41',\n 'CFG: ClassifierFreeGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.ClassifierFreeGuidance',\n 'Auto: AutoGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.AutoGuidance',\n 'Zero: ClassifierFreeZeroStar': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.ClassifierFreeZeroStarGuidance',\n 'PAG: PerturbedAttentionGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.PerturbedAttentionGuidance',\n 'APG: AdaptiveProjectedGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.AdaptiveProjectedGuidance',\n 'SLG: SkipLayerGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.SkipLayerGuidance',\n 'SEG: SmoothedEnergyGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.SmoothedEnergyGuidance',\n 'TCFG: TangentialClassifierFreeGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.TangentialClassifierFreeGuidance',\n 'FDG: FrequencyDecoupledGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.FrequencyDecoupledGuidance',\n};\n\nexport function getGuidanceDocs(guider: GuiderLike): void {\n const key = typeof guider === 'object' && guider?.label ? guider.label : guider;\n const url = guiders[key as string];\n log('getGuidanceDocs', guider, url);\n if (url) window.open(url, '_blank');\n}\n\nwindow.getGuidanceDocs = getGuidanceDocs;\n", "/* eslint max-classes-per-file: [\"error\", 2] */\n\ninterface TimesheetItem {\n start: number;\n end: number;\n label: string;\n type: string;\n}\n\nclass Bubble {\n type: string;\n label: string;\n min: number;\n start: number;\n end: number;\n scale: number;\n offset: number;\n width: number;\n duration: number;\n title: string;\n\n constructor(min: number, start: number, end: number, label: string, scale: number, type: string) {\n this.type = type;\n this.label = label;\n this.min = min;\n this.start = start;\n this.end = end;\n this.scale = scale;\n this.offset = Math.round(this.scale * (this.start - this.min));\n this.width = Math.round(this.scale * (this.end - this.start));\n this.duration = Math.round(1000 * (this.end - this.start)) / 1000;\n this.title = `Job: ${this.label}\\nDuration: ${this.duration}s\\nStart: ${new Date(1000 * this.start).toLocaleString()}\\nEnd: ${new Date(1000 * this.end).toLocaleString()}`;\n }\n\n getDateLabel(): number {\n return Math.round(1000 * (this.end - this.start)) / 1000;\n }\n}\n\nexport class Timesheet {\n min: number;\n max: number;\n data: TimesheetItem[];\n container: HTMLElement;\n scale: number;\n\n constructor(container: HTMLElement, data: TimesheetItem[]) {\n this.min = Math.floor(data[0].start);\n this.max = Math.round(data[data.length - 1].end + 0.5);\n this.data = data;\n this.container = container;\n const box = container.getBoundingClientRect();\n const width = box.width - 140;\n this.scale = width / (this.max - this.min);\n\n // draw sections\n let html: string[] = [];\n for (let c = 0; c <= this.max - this.min; c++) html.push(`
`);\n container.className = 'timesheet color-scheme-default';\n container.innerHTML = `
${html.join('')}
`;\n\n // insert data\n html = [];\n for (let n = 0, m = this.data.length; n < m; n++) {\n const cur = this.data[n];\n const bubble = new Bubble(this.min, cur.start, cur.end, cur.label, this.scale, cur.type);\n const line = [\n ``,\n `${bubble.duration} `,\n `${bubble.label}`,\n ].join('');\n html.push(`
  • ${line}
    • `);\n }\n this.container.innerHTML += `
      ${html.join('')}
    `;\n }\n}\n", "import { Timesheet } from './timesheet';\nimport { log } from './logger';\nimport { authFetch } from './authWrap';\n\ninterface HistoryEntry {\n timestamp: number;\n id: string;\n job: string;\n op: string;\n duration?: number;\n outputs: string[];\n type?: 'inference' | 'io' | 'default';\n}\n\ninterface TimelineEntry {\n start: number;\n end: number;\n label: string;\n type: 'inference' | 'io' | 'default';\n}\n\nconst inferenceTypes = ['inference', 'vae', 'te'];\nconst ioTypes = ['load', 'save'];\n\nexport function refreshHistory() {\n log('refreshHistory');\n authFetch(`${window.api}/history`, { priority: 'low' }).then((res) => {\n if (!res) return;\n const timeline = document.getElementById('history_timeline');\n const table = document.getElementById('history_table');\n if (!timeline || !table) return;\n timeline.innerHTML = '';\n res.json().then((rawData) => {\n let data = rawData as HistoryEntry[];\n if (!data || !data.length) {\n table.innerHTML = '

    No history data available.

    ';\n return;\n }\n\n // build table\n let html = '';\n for (const entry of data) {\n const ts = new Date(1000 * entry.timestamp).toLocaleString();\n const duration = entry.duration ? (entry.duration).toFixed(3) : '';\n const outputs = entry.outputs.join(', ');\n html += ``;\n }\n html += '
    TimeIDJobActionDurationOutputs
    ${ts}${entry.id}${entry.job}${entry.op}${duration}${outputs}
    ';\n table.innerHTML = html;\n\n // crop data to last processing session\n let startIdx = -1;\n for (let i = data.length - 1; i >= 0; --i) {\n const e = data[i];\n if ((e.job === 'control' || e.job === 'text' || e.job === 'control' || e.job === 'image') && (e.op === 'begin')) {\n startIdx = i;\n break;\n }\n }\n if (startIdx >= 0) data = data.slice(startIdx);\n\n // build timeline\n const ts: TimelineEntry[] = [];\n for (const entry of data) {\n if (entry.op === 'begin') {\n const start = entry.timestamp;\n const endEntry = data.find((e) => (e.id === entry.id && e.op === 'end'));\n const end = endEntry?.timestamp ?? data[data.length - 1].timestamp;\n if (end - start < 0.02) continue; // skip very short entries\n if (inferenceTypes.some((type) => entry.job.toLowerCase().startsWith(type))) entry.type = 'inference';\n else if (ioTypes.some((type) => entry.job.toLowerCase().startsWith(type))) entry.type = 'io';\n else entry.type = 'default';\n if (start && end) ts.push({ start, end, label: entry.job, type: entry.type });\n }\n }\n if (!ts.length) return;\n // eslint-disable-next-line no-new\n new Timesheet(timeline, ts);\n });\n });\n}\n\nwindow.refreshHistory = refreshHistory;\n", "import { gradioApp, onAfterUiUpdate } from './script';\nimport { get_tab_index } from './ui';\n\nlet currentWidth: number | null = null;\nlet currentHeight: number | null = null;\nlet arFrameTimeout: ReturnType | undefined;\n\nfunction dimensionChange(e: Event, isWidth: boolean, isHeight: boolean): void {\n const { target } = e;\n if (!(target instanceof HTMLInputElement)) return;\n if (isWidth) currentWidth = Number(target.value);\n if (isHeight) currentHeight = Number(target.value);\n const tabImg2img = gradioApp().querySelector('#tab_img2img');\n if (!(tabImg2img instanceof HTMLElement)) return;\n const inImg2img = tabImg2img.style.display === 'block';\n if (!inImg2img) return;\n let targetElement: HTMLImageElement | null = null;\n const tabIndex = get_tab_index('mode_img2img');\n if (tabIndex === 0) targetElement = gradioApp().querySelector('#img2img_image div[data-testid=image] img'); // img2img\n else if (tabIndex === 1) targetElement = gradioApp().querySelector('#img2img_sketch div[data-testid=image] img'); // Sketch\n else if (tabIndex === 2) targetElement = gradioApp().querySelector('#img2maskimg div[data-testid=image] img'); // Inpaint\n else if (tabIndex === 3) targetElement = gradioApp().querySelector('#composite div[data-testid=image] img'); // Inpaint sketch\n\n if (targetElement && currentWidth && currentHeight) {\n let arPreviewRect = gradioApp().querySelector('#imageARPreview');\n if (!arPreviewRect) {\n arPreviewRect = document.createElement('div');\n arPreviewRect.id = 'imageARPreview';\n gradioApp().appendChild(arPreviewRect);\n }\n\n const viewportOffset = targetElement.getBoundingClientRect();\n const viewportscale = Math.min(targetElement.clientWidth / targetElement.naturalWidth, targetElement.clientHeight / targetElement.naturalHeight);\n const scaledx = targetElement.naturalWidth * viewportscale;\n const scaledy = targetElement.naturalHeight * viewportscale;\n const cleintRectTop = (viewportOffset.top + window.scrollY);\n const cleintRectLeft = (viewportOffset.left + window.scrollX);\n const cleintRectCentreY = cleintRectTop + (targetElement.clientHeight / 2);\n const cleintRectCentreX = cleintRectLeft + (targetElement.clientWidth / 2);\n const arscale = Math.min(scaledx / currentWidth, scaledy / currentHeight);\n const arscaledx = currentWidth * arscale;\n const arscaledy = currentHeight * arscale;\n const arRectTop = cleintRectCentreY - (arscaledy / 2);\n const arRectLeft = cleintRectCentreX - (arscaledx / 2);\n const arRectWidth = arscaledx;\n const arRectHeight = arscaledy;\n arPreviewRect.style.top = `${arRectTop}px`;\n arPreviewRect.style.left = `${arRectLeft}px`;\n arPreviewRect.style.width = `${arRectWidth}px`;\n arPreviewRect.style.height = `${arRectHeight}px`;\n\n if (arFrameTimeout) clearTimeout(arFrameTimeout);\n arFrameTimeout = setTimeout(() => { arPreviewRect.style.display = 'none'; }, 2000);\n arPreviewRect.style.display = 'block';\n }\n}\n\nexport function aspectRatioCallback(): void {\n const arPreviewRect = gradioApp().querySelector('#imageARPreview');\n if (arPreviewRect instanceof HTMLElement) arPreviewRect.style.display = 'none';\n const tabImg2img = gradioApp().querySelector('#tab_img2img');\n if (tabImg2img instanceof HTMLElement) {\n const inImg2img = tabImg2img.style.display === 'block';\n if (inImg2img) {\n const inputs = gradioApp().querySelectorAll('input');\n inputs.forEach((e) => {\n if (!(e instanceof HTMLInputElement) || !(e.parentElement instanceof HTMLElement)) return;\n const isWidth = e.parentElement.id === 'img2img_width';\n const isHeight = e.parentElement.id === 'img2img_height';\n if ((isWidth || isHeight) && !e.classList.contains('scrollwatch')) {\n e.addEventListener('input', (evt) => { dimensionChange(evt, isWidth, isHeight); });\n e.classList.add('scrollwatch');\n }\n if (isWidth) currentWidth = Number(e.value);\n if (isHeight) currentHeight = Number(e.value);\n });\n }\n }\n}\n\nonAfterUiUpdate(aspectRatioCallback);\n", "import { gradioApp, onAfterUiUpdate } from './script';\n\n// Aspect-ratio lock for the paired width/height sliders. The math runs client-side and debounced,\n// and only the partner axis is ever written, never the field being edited; writing the edited field\n// back is what yanked the value mid-type when this went through a gradio round-trip. Programmatic\n// updates dispatch a synthetic input event so gradio's store stays in sync. State is keyed per\n// dropdown element so duplicate elem ids across tabs stay isolated.\n\nconst RES_DEBOUNCE = 350;\nconst AR_DEBOUNCE = 120;\nconst timers = new WeakMap>();\nconst busy = new WeakSet();\n\nfunction parseAR(ar: string): [number, number] | null {\n if (!ar || ar === 'AR') return null;\n const parts = ar.split(':');\n if (parts.length !== 2) return null;\n const w = parseInt(parts[0], 10);\n const h = parseInt(parts[1], 10);\n return (w > 0 && h > 0) ? [w, h] : null;\n}\n\nfunction numberInput(group: Element): HTMLInputElement | null {\n const inp = group.querySelector('input[type=number]') || group.querySelector('input');\n return inp instanceof HTMLInputElement ? inp : null;\n}\n\nfunction readValue(group: Element): number {\n const inp = numberInput(group);\n return inp ? Number(inp.value) : 0;\n}\n\nfunction writeValue(group: Element, raw: number): void {\n const inp = numberInput(group);\n if (!inp) return;\n const step = Number(inp.step) || 8;\n const min = inp.min !== '' ? Number(inp.min) : 0;\n const max = inp.max !== '' ? Number(inp.max) : 8192;\n const value = Math.max(min, Math.min(max, Math.round(raw / step) * step));\n if (value === Number(inp.value)) return; // unchanged: skip so the listeners do not refire\n group.querySelectorAll('input').forEach((el) => {\n if (!(el instanceof HTMLInputElement)) return;\n el.value = String(value);\n const e = new Event('input', { bubbles: true });\n Object.defineProperty(e, 'target', { value: el });\n el.dispatchEvent(e);\n });\n}\n\nfunction arValue(arEl: Element): string {\n const inp = arEl.querySelector('input');\n return inp instanceof HTMLInputElement ? inp.value : 'AR';\n}\n\nfunction pairOf(arEl: Element): { width: Element; height: Element } | null {\n let container: Element | null = arEl.parentElement;\n for (let i = 0; i < 6 && container; i++) {\n const width = container.querySelector('[id$=\"_width\"]');\n const height = container.querySelector('[id$=\"_height\"]');\n if (width && height) return { width, height };\n container = container.parentElement;\n }\n return null;\n}\n\nfunction settle(arEl: Element, source: 'width' | 'height'): void {\n const ar = parseAR(arValue(arEl));\n if (!ar) return;\n const pair = pairOf(arEl);\n if (!pair) return;\n const [rw, rh] = ar;\n busy.add(arEl);\n if (source === 'height') writeValue(pair.width, (readValue(pair.height) * rw) / rh);\n else writeValue(pair.height, (readValue(pair.width) * rh) / rw);\n busy.delete(arEl);\n}\n\nfunction schedule(arEl: Element, source: 'width' | 'height', delay: number): void {\n if (busy.has(arEl)) return; // ignore the input events our own writes dispatch\n clearTimeout(timers.get(arEl));\n timers.set(arEl, setTimeout(() => settle(arEl, source), delay));\n}\n\nfunction flush(arEl: Element, source: 'width' | 'height'): void {\n if (busy.has(arEl)) return;\n clearTimeout(timers.get(arEl));\n settle(arEl, source);\n}\n\nfunction bind(arEl: Element, group: Element, source: 'width' | 'height'): void {\n group.querySelectorAll('input').forEach((el) => {\n if (!(el instanceof HTMLInputElement) || el.classList.contains('ar-lock-bound')) return;\n el.classList.add('ar-lock-bound');\n el.addEventListener('input', () => schedule(arEl, source, RES_DEBOUNCE));\n el.addEventListener('change', () => flush(arEl, source)); // commit on blur, enter, or slider release\n });\n}\n\nexport function setupResolutionLock(): void {\n gradioApp().querySelectorAll('.ar-dropdown').forEach((arEl) => {\n const pair = pairOf(arEl);\n if (!pair) return;\n bind(arEl, pair.width, 'width');\n bind(arEl, pair.height, 'height');\n arEl.querySelectorAll('input').forEach((el) => {\n if (!(el instanceof HTMLInputElement) || el.classList.contains('ar-lock-bound')) return;\n el.classList.add('ar-lock-bound');\n el.addEventListener('change', () => flush(arEl, 'width')); // new ratio: keep width, derive height\n el.addEventListener('input', () => schedule(arEl, 'width', AR_DEBOUNCE));\n });\n });\n}\n\nonAfterUiUpdate(setupResolutionLock);\n", "import { updateInput } from './ui';\n\nexport function keyupEditAttention(event: KeyboardEvent): void {\n const target = (event as any).originalTarget || event.composedPath()[0];\n if (!(target instanceof HTMLTextAreaElement)) return;\n if (!target.matches(\"*:is([id*='_toprow'] [id*='_prompt'], .prompt) textarea\")) return;\n if (!(event.metaKey || event.ctrlKey)) return;\n const isPlus = event.key === 'ArrowUp';\n const isMinus = event.key === 'ArrowDown';\n if (!isPlus && !isMinus) return;\n let { selectionStart } = target;\n let { selectionEnd } = target;\n let text = target.value;\n\n function selectCurrentParenthesisBlock(OPEN: string, CLOSE: string): boolean {\n if (selectionStart !== selectionEnd) return false;\n\n // Find opening parenthesis around current cursor\n const before = text.substring(0, selectionStart);\n let beforeParen = before.lastIndexOf(OPEN);\n if (beforeParen === -1) return false;\n let beforeParenClose = before.lastIndexOf(CLOSE);\n while (beforeParenClose !== -1 && beforeParenClose > beforeParen) {\n beforeParen = before.lastIndexOf(OPEN, beforeParen - 1);\n beforeParenClose = before.lastIndexOf(CLOSE, beforeParenClose - 1);\n }\n\n // Find closing parenthesis around current cursor\n const after = text.substring(selectionStart);\n let afterParen = after.indexOf(CLOSE);\n if (afterParen === -1) return false;\n let afterParenOpen = after.indexOf(OPEN);\n while (afterParenOpen !== -1 && afterParen > afterParenOpen) {\n afterParen = after.indexOf(CLOSE, afterParen + 1);\n afterParenOpen = after.indexOf(OPEN, afterParenOpen + 1);\n }\n if (beforeParen === -1 || afterParen === -1) return false;\n\n // Set the selection to the text between the parenthesis\n const parenContent = text.substring(beforeParen + 1, selectionStart + afterParen);\n const lastColon = parenContent.lastIndexOf(':');\n selectionStart = beforeParen + 1;\n selectionEnd = selectionStart + lastColon;\n target.setSelectionRange(selectionStart, selectionEnd);\n return true;\n }\n\n function selectCurrentWord(): boolean {\n if (selectionStart !== selectionEnd) return false;\n const delimiters = `${window.opts.keyedit_delimiters} \\r\\n\\t`;\n // seek backward until to find beginning\n while (!delimiters.includes(text[selectionStart - 1]) && selectionStart > 0) selectionStart--;\n // seek forward to find end\n while (!delimiters.includes(text[selectionEnd]) && selectionEnd < text.length) selectionEnd++;\n target.setSelectionRange(selectionStart, selectionEnd);\n return true;\n }\n\n // If the user hasn't selected anything, let's select their current parenthesis block or word\n if (!selectCurrentParenthesisBlock('<', '>') && !selectCurrentParenthesisBlock('(', ')')) selectCurrentWord();\n event.preventDefault();\n\n let closeCharacter = ')';\n let delta = window.opts.keyedit_precision_attention;\n\n if (selectionStart > 0 && text[selectionStart - 1] === '<') {\n closeCharacter = '>';\n delta = window.opts.keyedit_precision_extra;\n } else if (selectionStart === 0 || text[selectionStart - 1] !== '(') {\n while (selectionEnd > selectionStart && text[selectionEnd - 1] === ' ') selectionEnd -= 1;\n if (selectionStart === selectionEnd) return;\n text = `${text.slice(0, selectionStart)}(${text.slice(selectionStart, selectionEnd)}:1.0)${text.slice(selectionEnd)}`;\n selectionStart += 1;\n selectionEnd += 1;\n }\n const end = text.slice(selectionEnd + 1).indexOf(closeCharacter) + 1;\n let weight: any = parseFloat(text.slice(selectionEnd + 1, selectionEnd + 1 + end));\n if (Number.isNaN(weight)) return;\n weight += isPlus ? delta : -delta;\n weight = parseFloat(weight.toPrecision(12));\n if (String(weight).length === 1) weight += '.0';\n if (closeCharacter === ')' && weight === 1) {\n text = text.slice(0, selectionStart - 1) + text.slice(selectionStart, selectionEnd) + text.slice(selectionEnd + 5);\n selectionStart--;\n selectionEnd--;\n } else {\n text = text.slice(0, selectionEnd + 1) + weight + text.slice(selectionEnd + 1 + end - 1);\n }\n target.focus();\n target.value = text;\n target.selectionStart = selectionStart;\n target.selectionEnd = selectionEnd;\n updateInput(target);\n}\n\naddEventListener('keydown', (event) => keyupEditAttention(event));\n", "/**\n*\n* jquery.sparkline.js\n*\n* v2.4.1\n* (c) Splunk, Inc\n* Contact: Gareth Watts (gareth@splunk.com)\n* http://omnipotent.net/jquery.sparkline/\n*\n* Generates inline sparkline charts from data supplied either to the method\n* or inline in HTML\n*\n* Compatible with Internet Explorer 6.0+ and modern browsers equipped with the canvas tag\n* (Firefox 2.0+, Safari, Opera, etc)\n*\n* License: New BSD License\n*\n* Copyright (c) 2012, Splunk Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without modification,\n* are permitted provided that the following conditions are met:\n*\n* * Redistributions of source code must retain the above copyright notice,\n* this list of conditions and the following disclaimer.\n* * Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following disclaimer in the documentation\n* and/or other materials provided with the distribution.\n* * Neither the name of Splunk Inc nor the names of its contributors may\n* be used to endorse or promote products derived from this software without\n* specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY\n* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT\n* SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT\n* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*\n*\n* Usage:\n* $(selector).sparkline(values, options)\n*\n* If values is undefined or set to 'html' then the data values are read from the specified tag:\n*

    Sparkline: 1,4,6,6,8,5,3,5

    \n* $('.sparkline').sparkline();\n* There must be no spaces in the enclosed data set\n*\n* Otherwise values must be an array of numbers or null values\n*

    Sparkline: This text replaced if the browser is compatible

    \n* $('#sparkline1').sparkline([1,4,6,6,8,5,3,5])\n* $('#sparkline2').sparkline([1,4,6,null,null,5,3,5])\n*\n* Values can also be specified in an HTML comment, or as a values attribute:\n*

    Sparkline:

    \n*

    Sparkline:

    \n* $('.sparkline').sparkline();\n*\n* For line charts, x values can also be specified:\n*

    Sparkline: 1:1,2.7:4,3.4:6,5:6,6:8,8.7:5,9:3,10:5

    \n* $('#sparkline1').sparkline([ [1,1], [2.7,4], [3.4,6], [5,6], [6,8], [8.7,5], [9,3], [10,5] ])\n*\n* By default, options should be passed in as the second argument to the sparkline function:\n* $('.sparkline').sparkline([1,2,3,4], {type: 'bar'})\n*\n* Options can also be set by passing them on the tag itself. This feature is disabled by default though\n* as there's a slight performance overhead:\n* $('.sparkline').sparkline([1,2,3,4], {enableTagOptions: true})\n*

    Sparkline: loading

    \n* Prefix all options supplied as tag attribute with \"spark\" (configurable by setting tagOptionsPrefix)\n*\n* Supported options:\n* lineColor - Color of the line used for the chart\n* fillColor - Color used to fill in the chart - Set to '' or false for a transparent chart\n* width - Width of the chart - Defaults to 3 times the number of values in pixels\n* height - Height of the chart - Defaults to the height of the containing element\n* chartRangeMin - Specify the minimum value to use for the Y range of the chart - Defaults to the minimum value supplied\n* chartRangeMax - Specify the maximum value to use for the Y range of the chart - Defaults to the maximum value supplied\n* chartRangeClip - Clip out of range values to the max/min specified by chartRangeMin and chartRangeMax\n* chartRangeMinX - Specify the minimum value to use for the X range of the chart - Defaults to the minimum value supplied\n* chartRangeMaxX - Specify the maximum value to use for the X range of the chart - Defaults to the maximum value supplied\n* composite - If true then don't erase any existing chart attached to the tag, but draw\n* another chart over the top - Note that width and height are ignored if an\n* existing chart is detected.\n* tagValuesAttribute - Name of tag attribute to check for data values - Defaults to 'values'\n* enableTagOptions - Whether to check tags for sparkline options\n* tagOptionsPrefix - Prefix used for options supplied as tag attributes - Defaults to 'spark'\n* disableHiddenCheck - If set to true, then the plugin will assume that charts will never be drawn into a\n* hidden dom element, avoding a browser reflow\n* disableInteraction - If set to true then all mouseover/click interaction behaviour will be disabled,\n* making the plugin perform much like it did in 1.x\n* disableTooltips - If set to true then tooltips will be disabled - Defaults to false (tooltips enabled)\n* disableHighlight - If set to true then highlighting of selected chart elements on mouseover will be disabled\n* defaults to false (highlights enabled)\n* highlightLighten - Factor to lighten/darken highlighted chart values by - Defaults to 1.4 for a 40% increase\n* tooltipContainer - Specify which DOM element the tooltip should be rendered into - defaults to document.body\n* tooltipClassname - Optional CSS classname to apply to tooltips - If not specified then a default style will be applied\n* tooltipOffsetX - How many pixels away from the mouse pointer to render the tooltip on the X axis\n* tooltipOffsetY - How many pixels away from the mouse pointer to render the tooltip on the r axis\n* tooltipFormatter - Optional callback that allows you to override the HTML displayed in the tooltip\n* callback is given arguments of (sparkline, options, fields)\n* tooltipChartTitle - If specified then the tooltip uses the string specified by this setting as a title\n* tooltipFormat - A format string or SPFormat object (or an array thereof for multiple entries)\n* to control the format of the tooltip\n* tooltipPrefix - A string to prepend to each field displayed in a tooltip\n* tooltipSuffix - A string to append to each field displayed in a tooltip\n* tooltipSkipNull - If true then null values will not have a tooltip displayed (defaults to true)\n* tooltipValueLookups - An object or range map to map field values to tooltip strings\n* (eg. to map -1 to \"Lost\", 0 to \"Draw\", and 1 to \"Win\")\n* numberFormatter - Optional callback for formatting numbers in tooltips\n* numberDigitGroupSep - Character to use for group separator in numbers \"1,234\" - Defaults to \",\"\n* numberDecimalMark - Character to use for the decimal point when formatting numbers - Defaults to \".\"\n* numberDigitGroupCount - Number of digits between group separator - Defaults to 3\n*\n* There are 7 types of sparkline, selected by supplying a \"type\" option of 'line' (default),\n* 'bar', 'tristate', 'bullet', 'discrete', 'pie' or 'box'\n* line - Line chart. Options:\n* spotColor - Set to '' to not end each line in a circular spot\n* minSpotColor - If set, color of spot at minimum value\n* maxSpotColor - If set, color of spot at maximum value\n* spotRadius - Radius in pixels\n* lineWidth - Width of line in pixels\n* normalRangeMin\n* normalRangeMax - If set draws a filled horizontal bar between these two values marking the \"normal\"\n* or expected range of values\n* normalRangeColor - Color to use for the above bar\n* drawNormalOnTop - Draw the normal range above the chart fill color if true\n* defaultPixelsPerValue - Defaults to 3 pixels of width for each value in the chart\n* highlightSpotColor - The color to use for drawing a highlight spot on mouseover - Set to null to disable\n* highlightLineColor - The color to use for drawing a highlight line on mouseover - Set to null to disable\n* valueSpots - Specify which points to draw spots on, and in which color. Accepts a range map\n*\n* bar - Bar chart. Options:\n* barColor - Color of bars for postive values\n* negBarColor - Color of bars for negative values\n* zeroColor - Color of bars with zero values\n* nullColor - Color of bars with null values - Defaults to omitting the bar entirely\n* barWidth - Width of bars in pixels\n* colorMap - Optional mappnig of values to colors to override the *BarColor values above\n* can be an Array of values to control the color of individual bars or a range map\n* to specify colors for individual ranges of values\n* barSpacing - Gap between bars in pixels\n* zeroAxis - Centers the y-axis around zero if true\n*\n* tristate - Charts values of win (>0), lose (<0) or draw (=0)\n* posBarColor - Color of win values\n* negBarColor - Color of lose values\n* zeroBarColor - Color of draw values\n* barWidth - Width of bars in pixels\n* barSpacing - Gap between bars in pixels\n* colorMap - Optional mappnig of values to colors to override the *BarColor values above\n* can be an Array of values to control the color of individual bars or a range map\n* to specify colors for individual ranges of values\n*\n* discrete - Options:\n* lineHeight - Height of each line in pixels - Defaults to 30% of the graph height\n* thesholdValue - Values less than this value will be drawn using thresholdColor instead of lineColor\n* thresholdColor\n*\n* bullet - Values for bullet graphs msut be in the order: target, performance, range1, range2, range3, ...\n* options:\n* targetColor - The color of the vertical target marker\n* targetWidth - The width of the target marker in pixels\n* performanceColor - The color of the performance measure horizontal bar\n* rangeColors - Colors to use for each qualitative range background color\n*\n* pie - Pie chart. Options:\n* sliceColors - An array of colors to use for pie slices\n* offset - Angle in degrees to offset the first slice - Try -90 or +90\n* borderWidth - Width of border to draw around the pie chart, in pixels - Defaults to 0 (no border)\n* borderColor - Color to use for the pie chart border - Defaults to #000\n*\n* box - Box plot. Options:\n* raw - Set to true to supply pre-computed plot points as values\n* values should be: low_outlier, low_whisker, q1, median, q3, high_whisker, high_outlier\n* When set to false you can supply any number of values and the box plot will\n* be computed for you. Default is false.\n* showOutliers - Set to true (default) to display outliers as circles\n* outlierIQR - Interquartile range used to determine outliers. Default 1.5\n* boxLineColor - Outline color of the box\n* boxFillColor - Fill color for the box\n* whiskerColor - Line color used for whiskers\n* outlierLineColor - Outline color of outlier circles\n* outlierFillColor - Fill color of the outlier circles\n* spotRadius - Radius of outlier circles\n* medianColor - Line color of the median line\n* target - Draw a target cross hair at the supplied value (default undefined)\n*\n*\n*\n* Examples:\n* $('#sparkline1').sparkline(myvalues, { lineColor: '#f00', fillColor: false });\n* $('.barsparks').sparkline('html', { type:'bar', height:'40px', barWidth:5 });\n* $('#tristate').sparkline([1,1,-1,1,0,0,-1], { type:'tristate' }):\n* $('#discrete').sparkline([1,3,4,5,5,3,4,5], { type:'discrete' });\n* $('#bullet').sparkline([10,12,12,9,7], { type:'bullet' });\n* $('#pie').sparkline([1,1,2], { type:'pie' });\n*/\n\n/*jslint regexp: true, browser: true, jquery: true, white: true, nomen: false, plusplus: false, maxerr: 500, indent: 4 */\n\n(function(document, Math, undefined) { // performance/minified-size optimization\n(function(factory) {\n if(typeof define === 'function' && define.amd) {\n define(['jquery'], factory);\n } else if (jQuery && !jQuery.fn.sparkline) {\n factory(jQuery);\n }\n}\n(function($) {\n 'use strict';\n\n var UNSET_OPTION = {},\n getDefaults, createClass, SPFormat, clipval, quartile, normalizeValue, normalizeValues,\n remove, isNumber, all, sum, addCSS, ensureArray, formatNumber, RangeMap,\n MouseHandler, Tooltip, barHighlightMixin,\n line, bar, tristate, discrete, bullet, pie, box, defaultStyles, initStyles,\n VShape, VCanvas_base, VCanvas_canvas, VCanvas_vml, pending, shapeCount = 0;\n\n /**\n * Default configuration settings\n */\n getDefaults = function () {\n return {\n // Settings common to most/all chart types\n common: {\n type: 'line',\n lineColor: '#00f',\n fillColor: '#cdf',\n defaultPixelsPerValue: 3,\n width: 'auto',\n height: 'auto',\n composite: false,\n tagValuesAttribute: 'values',\n tagOptionsPrefix: 'spark',\n enableTagOptions: false,\n enableHighlight: true,\n highlightLighten: 1.4,\n tooltipSkipNull: true,\n tooltipPrefix: '',\n tooltipSuffix: '',\n disableHiddenCheck: false,\n numberFormatter: false,\n numberDigitGroupCount: 3,\n numberDigitGroupSep: ',',\n numberDecimalMark: '.',\n disableTooltips: false,\n disableInteraction: false\n },\n // Defaults for line charts\n line: {\n spotColor: '#f80',\n highlightSpotColor: '#5f5',\n highlightLineColor: '#f22',\n spotRadius: 1.5,\n minSpotColor: '#f80',\n maxSpotColor: '#f80',\n lineWidth: 1,\n normalRangeMin: undefined,\n normalRangeMax: undefined,\n normalRangeColor: '#ccc',\n drawNormalOnTop: false,\n chartRangeMin: undefined,\n chartRangeMax: undefined,\n chartRangeMinX: undefined,\n chartRangeMaxX: undefined,\n tooltipFormat: new SPFormat('● {{prefix}}{{y}}{{suffix}}')\n },\n // Defaults for bar charts\n bar: {\n barColor: '#3366cc',\n negBarColor: '#f44',\n stackedBarColor: ['#3366cc', '#dc3912', '#ff9900', '#109618', '#66aa00',\n '#dd4477', '#0099c6', '#990099'],\n zeroColor: undefined,\n nullColor: undefined,\n zeroAxis: true,\n barWidth: 4,\n barSpacing: 1,\n chartRangeMax: undefined,\n chartRangeMin: undefined,\n chartRangeClip: false,\n colorMap: undefined,\n tooltipFormat: new SPFormat('● {{prefix}}{{value}}{{suffix}}')\n },\n // Defaults for tristate charts\n tristate: {\n barWidth: 4,\n barSpacing: 1,\n posBarColor: '#6f6',\n negBarColor: '#f44',\n zeroBarColor: '#999',\n colorMap: {},\n tooltipFormat: new SPFormat('● {{value:map}}'),\n tooltipValueLookups: { map: { '-1': 'Loss', '0': 'Draw', '1': 'Win' } }\n },\n // Defaults for discrete charts\n discrete: {\n lineHeight: 'auto',\n thresholdColor: undefined,\n thresholdValue: 0,\n chartRangeMax: undefined,\n chartRangeMin: undefined,\n chartRangeClip: false,\n tooltipFormat: new SPFormat('{{prefix}}{{value}}{{suffix}}')\n },\n // Defaults for bullet charts\n bullet: {\n targetColor: '#f33',\n targetWidth: 3, // width of the target bar in pixels\n performanceColor: '#33f',\n rangeColors: ['#d3dafe', '#a8b6ff', '#7f94ff'],\n base: undefined, // set this to a number to change the base start number\n tooltipFormat: new SPFormat('{{fieldkey:fields}} - {{value}}'),\n tooltipValueLookups: { fields: {r: 'Range', p: 'Performance', t: 'Target'} }\n },\n // Defaults for pie charts\n pie: {\n offset: 0,\n sliceColors: ['#3366cc', '#dc3912', '#ff9900', '#109618', '#66aa00',\n '#dd4477', '#0099c6', '#990099'],\n borderWidth: 0,\n borderColor: '#000',\n tooltipFormat: new SPFormat('● {{value}} ({{percent.1}}%)')\n },\n // Defaults for box plots\n box: {\n raw: false,\n boxLineColor: '#000',\n boxFillColor: '#cdf',\n whiskerColor: '#000',\n outlierLineColor: '#333',\n outlierFillColor: '#fff',\n medianColor: '#f00',\n showOutliers: true,\n outlierIQR: 1.5,\n spotRadius: 1.5,\n target: undefined,\n targetColor: '#4a2',\n chartRangeMax: undefined,\n chartRangeMin: undefined,\n tooltipFormat: new SPFormat('{{field:fields}}: {{value}}'),\n tooltipFormatFieldlistKey: 'field',\n tooltipValueLookups: { fields: { lq: 'Lower Quartile', med: 'Median',\n uq: 'Upper Quartile', lo: 'Left Outlier', ro: 'Right Outlier',\n lw: 'Left Whisker', rw: 'Right Whisker'} }\n }\n };\n };\n\n // You can have tooltips use a css class other than jqstooltip by specifying tooltipClassname\n defaultStyles = '.jqstooltip { ' +\n 'position: absolute;' +\n 'left: 0px;' +\n 'top: 0px;' +\n 'visibility: hidden;' +\n 'background: rgb(0, 0, 0) transparent;' +\n 'background-color: rgba(0,0,0,0.6);' +\n 'filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#99000000, endColorstr=#99000000);' +\n '-ms-filter: \"progid:DXImageTransform.Microsoft.gradient(startColorstr=#99000000, endColorstr=#99000000)\";' +\n 'color: white;' +\n 'font: 10px arial, san serif;' +\n 'text-align: left;' +\n 'white-space: nowrap;' +\n 'padding: 5px;' +\n 'border: 1px solid white;' +\n 'box-sizing: content-box;' +\n 'z-index: 10000;' +\n '}' +\n '.jqsfield { ' +\n 'color: white;' +\n 'font: 10px arial, san serif;' +\n 'text-align: left;' +\n '}';\n\n /**\n * Utilities\n */\n\n createClass = function (/* [baseclass, [mixin, ...]], definition */) {\n var Class, args;\n Class = function () {\n this.init.apply(this, arguments);\n };\n if (arguments.length > 1) {\n if (arguments[0]) {\n Class.prototype = $.extend(new arguments[0](), arguments[arguments.length - 1]);\n Class._super = arguments[0].prototype;\n } else {\n Class.prototype = arguments[arguments.length - 1];\n }\n if (arguments.length > 2) {\n args = Array.prototype.slice.call(arguments, 1, -1);\n args.unshift(Class.prototype);\n $.extend.apply($, args);\n }\n } else {\n Class.prototype = arguments[0];\n }\n Class.prototype.cls = Class;\n return Class;\n };\n\n /**\n * Wraps a format string for tooltips\n * {{x}}\n * {{x.2}\n * {{x:months}}\n */\n $.SPFormatClass = SPFormat = createClass({\n fre: /\\{\\{([\\w.]+?)(:(.+?))?\\}\\}/g,\n precre: /(\\w+)\\.(\\d+)/,\n\n init: function (format, fclass) {\n this.format = format;\n this.fclass = fclass;\n },\n\n render: function (fieldset, lookups, options) {\n var self = this,\n fields = fieldset,\n match, token, lookupkey, fieldvalue, prec;\n return this.format.replace(this.fre, function () {\n var lookup;\n token = arguments[1];\n lookupkey = arguments[3];\n match = self.precre.exec(token);\n if (match) {\n prec = match[2];\n token = match[1];\n } else {\n prec = false;\n }\n fieldvalue = fields[token];\n if (fieldvalue === undefined) {\n return '';\n }\n if (lookupkey && lookups && lookups[lookupkey]) {\n lookup = lookups[lookupkey];\n if (lookup.get) { // RangeMap\n return lookups[lookupkey].get(fieldvalue) || fieldvalue;\n } else {\n return lookups[lookupkey][fieldvalue] || fieldvalue;\n }\n }\n if (isNumber(fieldvalue)) {\n if (options.get('numberFormatter')) {\n fieldvalue = options.get('numberFormatter')(fieldvalue);\n } else {\n fieldvalue = formatNumber(fieldvalue, prec,\n options.get('numberDigitGroupCount'),\n options.get('numberDigitGroupSep'),\n options.get('numberDecimalMark'));\n }\n }\n return fieldvalue;\n });\n }\n });\n\n // convience method to avoid needing the new operator\n $.spformat = function(format, fclass) {\n return new SPFormat(format, fclass);\n };\n\n clipval = function (val, min, max) {\n if (val < min) {\n return min;\n }\n if (val > max) {\n return max;\n }\n return val;\n };\n\n quartile = function (values, q) {\n var vl;\n if (q === 2) {\n vl = Math.floor(values.length / 2);\n return values.length % 2 ? values[vl] : (values[vl-1] + values[vl]) / 2;\n } else {\n if (values.length % 2 ) { // odd\n vl = (values.length * q + q) / 4;\n return vl % 1 ? (values[Math.floor(vl)] + values[Math.floor(vl) - 1]) / 2 : values[vl-1];\n } else { //even\n vl = (values.length * q + 2) / 4;\n return vl % 1 ? (values[Math.floor(vl)] + values[Math.floor(vl) - 1]) / 2 : values[vl-1];\n\n }\n }\n };\n\n normalizeValue = function (val) {\n var nf;\n switch (val) {\n case 'undefined':\n val = undefined;\n break;\n case 'null':\n val = null;\n break;\n case 'true':\n val = true;\n break;\n case 'false':\n val = false;\n break;\n default:\n nf = parseFloat(val);\n if (val == nf) {\n val = nf;\n }\n }\n return val;\n };\n\n normalizeValues = function (vals) {\n var i, result = [];\n for (i = vals.length; i--;) {\n result[i] = normalizeValue(vals[i]);\n }\n return result;\n };\n\n remove = function (vals, filter) {\n var i, vl, result = [];\n for (i = 0, vl = vals.length; i < vl; i++) {\n if (vals[i] !== filter) {\n result.push(vals[i]);\n }\n }\n return result;\n };\n\n isNumber = function (num) {\n return !isNaN(parseFloat(num)) && isFinite(num);\n };\n\n formatNumber = function (num, prec, groupsize, groupsep, decsep) {\n var p, i;\n num = (prec === false ? parseFloat(num).toString() : num.toFixed(prec)).split('');\n p = (p = $.inArray('.', num)) < 0 ? num.length : p;\n if (p < num.length) {\n num[p] = decsep;\n }\n for (i = p - groupsize; i > 0; i -= groupsize) {\n num.splice(i, 0, groupsep);\n }\n return num.join('');\n };\n\n // determine if all values of an array match a value\n // returns true if the array is empty\n all = function (val, arr, ignoreNull) {\n var i;\n for (i = arr.length; i--; ) {\n if (ignoreNull && arr[i] === null) continue;\n if (arr[i] !== val) {\n return false;\n }\n }\n return true;\n };\n\n // sums the numeric values in an array, ignoring other values\n sum = function (vals) {\n var total = 0, i;\n for (i = vals.length; i--;) {\n total += typeof vals[i] === 'number' ? vals[i] : 0;\n }\n return total;\n };\n\n ensureArray = function (val) {\n return $.isArray(val) ? val : [val];\n };\n\n // http://paulirish.com/2008/bookmarklet-inject-new-css-rules/\n addCSS = function(css) {\n var tag, iefail;\n if (document.createStyleSheet) {\n try {\n document.createStyleSheet().cssText = css;\n return;\n } catch (e) {\n // IE <= 9 maxes out at 31 stylesheets; inject into page instead.\n iefail = true;\n }\n }\n tag = document.createElement('style');\n tag.type = 'text/css';\n document.getElementsByTagName('head')[0].appendChild(tag);\n if (iefail) {\n document.styleSheets[document.styleSheets.length - 1].cssText = css;\n } else {\n tag[(typeof document.body.style.WebkitAppearance == 'string') /* webkit only */ ? 'innerText' : 'innerHTML'] = css;\n }\n };\n\n // Provide a cross-browser interface to a few simple drawing primitives\n $.fn.simpledraw = function (width, height, useExisting, interact) {\n var target, mhandler;\n if (useExisting && (target = this.data('_jqs_vcanvas'))) {\n return target;\n }\n\n if ($.fn.sparkline.canvas === false) {\n // We've already determined that neither Canvas nor VML are available\n return false;\n\n } else if ($.fn.sparkline.canvas === undefined) {\n // No function defined yet -- need to see if we support Canvas or VML\n var el = document.createElement('canvas');\n if (!!(el.getContext && el.getContext('2d'))) {\n // Canvas is available\n $.fn.sparkline.canvas = function(width, height, target, interact) {\n return new VCanvas_canvas(width, height, target, interact);\n };\n } else if (document.namespaces && !document.namespaces.v) {\n // VML is available\n document.namespaces.add('v', 'urn:schemas-microsoft-com:vml', '#default#VML');\n $.fn.sparkline.canvas = function(width, height, target, interact) {\n return new VCanvas_vml(width, height, target);\n };\n } else {\n // Neither Canvas nor VML are available\n $.fn.sparkline.canvas = false;\n return false;\n }\n }\n\n if (width === undefined) {\n width = $(this).innerWidth();\n }\n if (height === undefined) {\n height = $(this).innerHeight();\n }\n\n target = $.fn.sparkline.canvas(width, height, this, interact);\n\n mhandler = $(this).data('_jqs_mhandler');\n if (mhandler) {\n mhandler.registerCanvas(target);\n }\n return target;\n };\n\n $.fn.cleardraw = function () {\n var target = this.data('_jqs_vcanvas');\n if (target) {\n target.reset();\n }\n };\n\n $.RangeMapClass = RangeMap = createClass({\n init: function (map) {\n var key, range, rangelist = [];\n for (key in map) {\n if (map.hasOwnProperty(key) && typeof key === 'string' && key.indexOf(':') > -1) {\n range = key.split(':');\n range[0] = range[0].length === 0 ? -Infinity : parseFloat(range[0]);\n range[1] = range[1].length === 0 ? Infinity : parseFloat(range[1]);\n range[2] = map[key];\n rangelist.push(range);\n }\n }\n this.map = map;\n this.rangelist = rangelist || false;\n },\n\n get: function (value) {\n var rangelist = this.rangelist,\n i, range, result;\n if ((result = this.map[value]) !== undefined) {\n return result;\n }\n if (rangelist) {\n for (i = rangelist.length; i--;) {\n range = rangelist[i];\n if (range[0] <= value && range[1] >= value) {\n return range[2];\n }\n }\n }\n return undefined;\n }\n });\n\n // Convenience function\n $.range_map = function(map) {\n return new RangeMap(map);\n };\n\n MouseHandler = createClass({\n init: function (el, options) {\n var $el = $(el);\n this.$el = $el;\n this.options = options;\n this.currentPageX = 0;\n this.currentPageY = 0;\n this.el = el;\n this.splist = [];\n this.tooltip = null;\n this.over = false;\n this.displayTooltips = !options.get('disableTooltips');\n this.highlightEnabled = !options.get('disableHighlight');\n },\n\n registerSparkline: function (sp) {\n this.splist.push(sp);\n if (this.over) {\n this.updateDisplay();\n }\n },\n\n registerCanvas: function (canvas) {\n var $canvas = $(canvas.canvas);\n this.canvas = canvas;\n this.$canvas = $canvas;\n $canvas.mouseenter($.proxy(this.mouseenter, this));\n $canvas.mouseleave($.proxy(this.mouseleave, this));\n $canvas.click($.proxy(this.mouseclick, this));\n },\n\n reset: function (removeTooltip) {\n this.splist = [];\n if (this.tooltip && removeTooltip) {\n this.tooltip.remove();\n this.tooltip = undefined;\n }\n },\n\n mouseclick: function (e) {\n var clickEvent = $.Event('sparklineClick');\n clickEvent.originalEvent = e;\n clickEvent.sparklines = this.splist;\n this.$el.trigger(clickEvent);\n },\n\n mouseenter: function (e) {\n $(document.body).unbind('mousemove.jqs');\n $(document.body).bind('mousemove.jqs', $.proxy(this.mousemove, this));\n this.over = true;\n this.currentPageX = e.pageX;\n this.currentPageY = e.pageY;\n this.currentEl = e.target;\n if (!this.tooltip && this.displayTooltips) {\n this.tooltip = new Tooltip(this.options);\n this.tooltip.updatePosition(e.pageX, e.pageY);\n }\n this.updateDisplay();\n },\n\n mouseleave: function () {\n $(document.body).unbind('mousemove.jqs');\n var splist = this.splist,\n spcount = splist.length,\n needsRefresh = false,\n sp, i;\n this.over = false;\n this.currentEl = null;\n\n if (this.tooltip) {\n this.tooltip.remove();\n this.tooltip = null;\n }\n\n for (i = 0; i < spcount; i++) {\n sp = splist[i];\n if (sp.clearRegionHighlight()) {\n needsRefresh = true;\n }\n }\n\n if (needsRefresh) {\n this.canvas.render();\n }\n },\n\n mousemove: function (e) {\n this.currentPageX = e.pageX;\n this.currentPageY = e.pageY;\n this.currentEl = e.target;\n if (this.tooltip) {\n this.tooltip.updatePosition(e.pageX, e.pageY);\n }\n this.updateDisplay();\n },\n\n updateDisplay: function () {\n var splist = this.splist,\n spcount = splist.length,\n needsRefresh = false,\n offset = this.$canvas.offset(),\n localX = this.currentPageX - offset.left,\n localY = this.currentPageY - offset.top,\n tooltiphtml, sp, i, result, changeEvent;\n if (!this.over) {\n return;\n }\n for (i = 0; i < spcount; i++) {\n sp = splist[i];\n result = sp.setRegionHighlight(this.currentEl, localX, localY);\n if (result) {\n needsRefresh = true;\n }\n }\n if (needsRefresh) {\n changeEvent = $.Event('sparklineRegionChange');\n changeEvent.sparklines = this.splist;\n this.$el.trigger(changeEvent);\n if (this.tooltip) {\n tooltiphtml = '';\n for (i = 0; i < spcount; i++) {\n sp = splist[i];\n tooltiphtml += sp.getCurrentRegionTooltip();\n }\n this.tooltip.setContent(tooltiphtml);\n }\n if (!this.disableHighlight) {\n this.canvas.render();\n }\n }\n if (result === null) {\n this.mouseleave();\n }\n }\n });\n\n\n Tooltip = createClass({\n sizeStyle: 'position: static !important;' +\n 'display: block !important;' +\n 'visibility: hidden !important;' +\n 'float: left !important;',\n\n init: function (options) {\n var tooltipClassname = options.get('tooltipClassname', 'jqstooltip'),\n sizetipStyle = this.sizeStyle,\n offset;\n this.container = options.get('tooltipContainer') || document.body;\n this.tooltipOffsetX = options.get('tooltipOffsetX', 10);\n this.tooltipOffsetY = options.get('tooltipOffsetY', 12);\n // remove any previous lingering tooltip\n $('#jqssizetip').remove();\n $('#jqstooltip').remove();\n this.sizetip = $('
    ', {\n id: 'jqssizetip',\n style: sizetipStyle,\n 'class': tooltipClassname\n });\n this.tooltip = $('
    ', {\n id: 'jqstooltip',\n 'class': tooltipClassname\n }).appendTo(this.container);\n // account for the container's location\n offset = this.tooltip.offset();\n this.offsetLeft = offset.left;\n this.offsetTop = offset.top;\n this.hidden = true;\n $(window).unbind('resize.jqs scroll.jqs');\n $(window).bind('resize.jqs scroll.jqs', $.proxy(this.updateWindowDims, this));\n this.updateWindowDims();\n },\n\n updateWindowDims: function () {\n this.scrollTop = $(window).scrollTop();\n this.scrollLeft = $(window).scrollLeft();\n this.scrollRight = this.scrollLeft + $(window).width();\n this.updatePosition();\n },\n\n getSize: function (content) {\n this.sizetip.html(content).appendTo(this.container);\n this.width = this.sizetip.width() + 1;\n this.height = this.sizetip.height();\n this.sizetip.remove();\n },\n\n setContent: function (content) {\n if (!content) {\n this.tooltip.css('visibility', 'hidden');\n this.hidden = true;\n return;\n }\n this.getSize(content);\n this.tooltip.html(content)\n .css({\n 'width': this.width,\n 'height': this.height,\n 'visibility': 'visible'\n });\n if (this.hidden) {\n this.hidden = false;\n this.updatePosition();\n }\n },\n\n updatePosition: function (x, y) {\n if (x === undefined) {\n if (this.mousex === undefined) {\n return;\n }\n x = this.mousex - this.offsetLeft;\n y = this.mousey - this.offsetTop;\n\n } else {\n this.mousex = x = x - this.offsetLeft;\n this.mousey = y = y - this.offsetTop;\n }\n if (!this.height || !this.width || this.hidden) {\n return;\n }\n\n y -= this.height + this.tooltipOffsetY;\n x += this.tooltipOffsetX;\n\n if (y < this.scrollTop) {\n y = this.scrollTop;\n }\n if (x < this.scrollLeft) {\n x = this.scrollLeft;\n } else if (x + this.width > this.scrollRight) {\n x = this.scrollRight - this.width;\n }\n\n this.tooltip.css({\n 'left': x,\n 'top': y\n });\n },\n\n remove: function () {\n this.tooltip.remove();\n this.sizetip.remove();\n this.sizetip = this.tooltip = undefined;\n $(window).unbind('resize.jqs scroll.jqs');\n }\n });\n\n initStyles = function() {\n addCSS(defaultStyles);\n };\n\n $(initStyles);\n\n pending = [];\n $.fn.sparkline = function (userValues, userOptions) {\n return this.each(function () {\n var options = new $.fn.sparkline.options(this, userOptions),\n $this = $(this),\n render, i;\n render = function () {\n var values, width, height, tmp, mhandler, sp, vals;\n if (userValues === 'html' || userValues === undefined) {\n vals = this.getAttribute(options.get('tagValuesAttribute'));\n if (vals === undefined || vals === null) {\n vals = $this.html();\n }\n values = vals.replace(/(^\\s*\\s*$)|\\s+/g, '').split(',');\n } else {\n values = userValues;\n }\n\n width = options.get('width') === 'auto' ? values.length * options.get('defaultPixelsPerValue') : options.get('width');\n if (options.get('height') === 'auto') {\n if (!options.get('composite') || !$.data(this, '_jqs_vcanvas')) {\n // must be a better way to get the line height\n tmp = document.createElement('span');\n tmp.innerHTML = 'a';\n $this.html(tmp);\n height = $(tmp).innerHeight() || $(tmp).height();\n $(tmp).remove();\n tmp = null;\n }\n } else {\n height = options.get('height');\n }\n\n if (!options.get('disableInteraction')) {\n mhandler = $.data(this, '_jqs_mhandler');\n if (!mhandler) {\n mhandler = new MouseHandler(this, options);\n $.data(this, '_jqs_mhandler', mhandler);\n } else if (!options.get('composite')) {\n mhandler.reset();\n }\n } else {\n mhandler = false;\n }\n\n if (options.get('composite') && !$.data(this, '_jqs_vcanvas')) {\n if (!$.data(this, '_jqs_errnotify')) {\n alert('Attempted to attach a composite sparkline to an element with no existing sparkline');\n $.data(this, '_jqs_errnotify', true);\n }\n return;\n }\n\n sp = new $.fn.sparkline[options.get('type')](this, values, options, width, height);\n\n sp.render();\n\n if (mhandler) {\n mhandler.registerSparkline(sp);\n }\n };\n if (($(this).html() && !options.get('disableHiddenCheck') && $(this).is(':hidden')) || !$(this).parents('body').length) {\n if (!options.get('composite') && $.data(this, '_jqs_pending')) {\n // remove any existing references to the element\n for (i = pending.length; i; i--) {\n if (pending[i - 1][0] == this) {\n pending.splice(i - 1, 1);\n }\n }\n }\n pending.push([this, render]);\n $.data(this, '_jqs_pending', true);\n } else {\n render.call(this);\n }\n });\n };\n\n $.fn.sparkline.defaults = getDefaults();\n\n\n $.sparkline_display_visible = function () {\n var el, i, pl;\n var done = [];\n for (i = 0, pl = pending.length; i < pl; i++) {\n el = pending[i][0];\n if ($(el).is(':visible') && !$(el).parents().is(':hidden')) {\n pending[i][1].call(el);\n $.data(pending[i][0], '_jqs_pending', false);\n done.push(i);\n } else if (!$(el).closest('html').length && !$.data(el, '_jqs_pending')) {\n // element has been inserted and removed from the DOM\n // If it was not yet inserted into the dom then the .data request\n // will return true.\n // removing from the dom causes the data to be removed.\n $.data(pending[i][0], '_jqs_pending', false);\n done.push(i);\n }\n }\n for (i = done.length; i; i--) {\n pending.splice(done[i - 1], 1);\n }\n };\n\n\n /**\n * User option handler\n */\n $.fn.sparkline.options = createClass({\n init: function (tag, userOptions) {\n var extendedOptions, defaults, base, tagOptionType;\n this.userOptions = userOptions = userOptions || {};\n this.tag = tag;\n this.tagValCache = {};\n defaults = $.fn.sparkline.defaults;\n base = defaults.common;\n this.tagOptionsPrefix = userOptions.enableTagOptions && (userOptions.tagOptionsPrefix || base.tagOptionsPrefix);\n\n tagOptionType = this.getTagSetting('type');\n if (tagOptionType === UNSET_OPTION) {\n extendedOptions = defaults[userOptions.type || base.type];\n } else {\n extendedOptions = defaults[tagOptionType];\n }\n this.mergedOptions = $.extend({}, base, extendedOptions, userOptions);\n },\n\n\n getTagSetting: function (key) {\n var prefix = this.tagOptionsPrefix,\n val, i, pairs, keyval;\n if (prefix === false || prefix === undefined) {\n return UNSET_OPTION;\n }\n if (this.tagValCache.hasOwnProperty(key)) {\n val = this.tagValCache.key;\n } else {\n val = this.tag.getAttribute(prefix + key);\n if (val === undefined || val === null) {\n val = UNSET_OPTION;\n } else if (val.substr(0, 1) === '[') {\n val = val.substr(1, val.length - 2).split(',');\n for (i = val.length; i--;) {\n val[i] = normalizeValue(val[i].replace(/(^\\s*)|(\\s*$)/g, ''));\n }\n } else if (val.substr(0, 1) === '{') {\n pairs = val.substr(1, val.length - 2).split(',');\n val = {};\n for (i = pairs.length; i--;) {\n keyval = pairs[i].split(':', 2);\n val[keyval[0].replace(/(^\\s*)|(\\s*$)/g, '')] = normalizeValue(keyval[1].replace(/(^\\s*)|(\\s*$)/g, ''));\n }\n } else {\n val = normalizeValue(val);\n }\n this.tagValCache.key = val;\n }\n return val;\n },\n\n get: function (key, defaultval) {\n var tagOption = this.getTagSetting(key),\n result;\n if (tagOption !== UNSET_OPTION) {\n return tagOption;\n }\n return (result = this.mergedOptions[key]) === undefined ? defaultval : result;\n }\n });\n\n\n $.fn.sparkline._base = createClass({\n disabled: false,\n\n init: function (el, values, options, width, height) {\n this.el = el;\n this.$el = $(el);\n this.values = values;\n this.options = options;\n this.width = width;\n this.height = height;\n this.currentRegion = undefined;\n },\n\n /**\n * Setup the canvas\n */\n initTarget: function () {\n var interactive = !this.options.get('disableInteraction');\n if (!(this.target = this.$el.simpledraw(this.width, this.height, this.options.get('composite'), interactive))) {\n this.disabled = true;\n } else {\n this.canvasWidth = this.target.pixelWidth;\n this.canvasHeight = this.target.pixelHeight;\n }\n },\n\n /**\n * Actually render the chart to the canvas\n */\n render: function () {\n if (this.disabled) {\n this.el.innerHTML = '';\n return false;\n }\n return true;\n },\n\n /**\n * Return a region id for a given x/y co-ordinate\n */\n getRegion: function (x, y) {\n },\n\n /**\n * Highlight an item based on the moused-over x,y co-ordinate\n */\n setRegionHighlight: function (el, x, y) {\n var currentRegion = this.currentRegion,\n highlightEnabled = !this.options.get('disableHighlight'),\n newRegion;\n if (x > this.canvasWidth || y > this.canvasHeight || x < 0 || y < 0) {\n return null;\n }\n newRegion = this.getRegion(el, x, y);\n if (currentRegion !== newRegion) {\n if (currentRegion !== undefined && highlightEnabled) {\n this.removeHighlight();\n }\n this.currentRegion = newRegion;\n if (newRegion !== undefined && highlightEnabled) {\n this.renderHighlight();\n }\n return true;\n }\n return false;\n },\n\n /**\n * Reset any currently highlighted item\n */\n clearRegionHighlight: function () {\n if (this.currentRegion !== undefined) {\n this.removeHighlight();\n this.currentRegion = undefined;\n return true;\n }\n return false;\n },\n\n renderHighlight: function () {\n this.changeHighlight(true);\n },\n\n removeHighlight: function () {\n this.changeHighlight(false);\n },\n\n changeHighlight: function (highlight) {},\n\n /**\n * Fetch the HTML to display as a tooltip\n */\n getCurrentRegionTooltip: function () {\n var options = this.options,\n header = '',\n entries = [],\n fields, formats, formatlen, fclass, text, i,\n showFields, showFieldsKey, newFields, fv,\n formatter, format, fieldlen, j;\n if (this.currentRegion === undefined) {\n return '';\n }\n fields = this.getCurrentRegionFields();\n formatter = options.get('tooltipFormatter');\n if (formatter) {\n return formatter(this, options, fields);\n }\n if (options.get('tooltipChartTitle')) {\n header += '
    ' + options.get('tooltipChartTitle') + '
    \\n';\n }\n formats = this.options.get('tooltipFormat');\n if (!formats) {\n return '';\n }\n if (!$.isArray(formats)) {\n formats = [formats];\n }\n if (!$.isArray(fields)) {\n fields = [fields];\n }\n showFields = this.options.get('tooltipFormatFieldlist');\n showFieldsKey = this.options.get('tooltipFormatFieldlistKey');\n if (showFields && showFieldsKey) {\n // user-selected ordering of fields\n newFields = [];\n for (i = fields.length; i--;) {\n fv = fields[i][showFieldsKey];\n if ((j = $.inArray(fv, showFields)) != -1) {\n newFields[j] = fields[i];\n }\n }\n fields = newFields;\n }\n formatlen = formats.length;\n fieldlen = fields.length;\n for (i = 0; i < formatlen; i++) {\n format = formats[i];\n if (typeof format === 'string') {\n format = new SPFormat(format);\n }\n fclass = format.fclass || 'jqsfield';\n for (j = 0; j < fieldlen; j++) {\n if (!fields[j].isNull || !options.get('tooltipSkipNull')) {\n $.extend(fields[j], {\n prefix: options.get('tooltipPrefix'),\n suffix: options.get('tooltipSuffix')\n });\n text = format.render(fields[j], options.get('tooltipValueLookups'), options);\n entries.push('
    ' + text + '
    ');\n }\n }\n }\n if (entries.length) {\n return header + entries.join('\\n');\n }\n return '';\n },\n\n getCurrentRegionFields: function () {},\n\n calcHighlightColor: function (color, options) {\n var highlightColor = options.get('highlightColor'),\n lighten = options.get('highlightLighten'),\n parse, mult, rgbnew, i;\n if (highlightColor) {\n return highlightColor;\n }\n if (lighten) {\n // extract RGB values\n parse = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(color) || /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(color);\n if (parse) {\n rgbnew = [];\n mult = color.length === 4 ? 16 : 1;\n for (i = 0; i < 3; i++) {\n rgbnew[i] = clipval(Math.round(parseInt(parse[i + 1], 16) * mult * lighten), 0, 255);\n }\n return 'rgb(' + rgbnew.join(',') + ')';\n }\n\n }\n return color;\n }\n\n });\n\n barHighlightMixin = {\n changeHighlight: function (highlight) {\n var currentRegion = this.currentRegion,\n target = this.target,\n shapeids = this.regionShapes[currentRegion],\n newShapes;\n // will be null if the region value was null\n if (shapeids) {\n newShapes = this.renderRegion(currentRegion, highlight);\n if ($.isArray(newShapes) || $.isArray(shapeids)) {\n target.replaceWithShapes(shapeids, newShapes);\n this.regionShapes[currentRegion] = $.map(newShapes, function (newShape) {\n return newShape.id;\n });\n } else {\n target.replaceWithShape(shapeids, newShapes);\n this.regionShapes[currentRegion] = newShapes.id;\n }\n }\n },\n\n render: function () {\n var values = this.values,\n target = this.target,\n regionShapes = this.regionShapes,\n shapes, ids, i, j;\n\n if (!this.cls._super.render.call(this)) {\n return;\n }\n for (i = values.length; i--;) {\n shapes = this.renderRegion(i);\n if (shapes) {\n if ($.isArray(shapes)) {\n ids = [];\n for (j = shapes.length; j--;) {\n shapes[j].append();\n ids.push(shapes[j].id);\n }\n regionShapes[i] = ids;\n } else {\n shapes.append();\n regionShapes[i] = shapes.id; // store just the shapeid\n }\n } else {\n // null value\n regionShapes[i] = null;\n }\n }\n target.render();\n }\n };\n\n /**\n * Line charts\n */\n $.fn.sparkline.line = line = createClass($.fn.sparkline._base, {\n type: 'line',\n\n init: function (el, values, options, width, height) {\n line._super.init.call(this, el, values, options, width, height);\n this.vertices = [];\n this.regionMap = [];\n this.xvalues = [];\n this.yvalues = [];\n this.yminmax = [];\n this.hightlightSpotId = null;\n this.lastShapeId = null;\n this.initTarget();\n },\n\n getRegion: function (el, x, y) {\n var i,\n regionMap = this.regionMap; // maps regions to value positions\n for (i = regionMap.length; i--;) {\n if (regionMap[i] !== null && x >= regionMap[i][0] && x <= regionMap[i][1]) {\n return regionMap[i][2];\n }\n }\n return undefined;\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n isNull: this.yvalues[currentRegion] === null,\n x: this.xvalues[currentRegion],\n y: this.yvalues[currentRegion],\n color: this.options.get('lineColor'),\n fillColor: this.options.get('fillColor'),\n offset: currentRegion\n };\n },\n\n renderHighlight: function () {\n var currentRegion = this.currentRegion,\n target = this.target,\n vertex = this.vertices[currentRegion],\n options = this.options,\n spotRadius = options.get('spotRadius'),\n highlightSpotColor = options.get('highlightSpotColor'),\n highlightLineColor = options.get('highlightLineColor'),\n highlightSpot, highlightLine;\n\n if (!vertex) {\n return;\n }\n if (spotRadius && highlightSpotColor) {\n highlightSpot = target.drawCircle(vertex[0], vertex[1],\n spotRadius, undefined, highlightSpotColor);\n this.highlightSpotId = highlightSpot.id;\n target.insertAfterShape(this.lastShapeId, highlightSpot);\n }\n if (highlightLineColor) {\n highlightLine = target.drawLine(vertex[0], this.canvasTop, vertex[0],\n this.canvasTop + this.canvasHeight, highlightLineColor);\n this.highlightLineId = highlightLine.id;\n target.insertAfterShape(this.lastShapeId, highlightLine);\n }\n },\n\n removeHighlight: function () {\n var target = this.target;\n if (this.highlightSpotId) {\n target.removeShapeId(this.highlightSpotId);\n this.highlightSpotId = null;\n }\n if (this.highlightLineId) {\n target.removeShapeId(this.highlightLineId);\n this.highlightLineId = null;\n }\n },\n\n scanValues: function () {\n var values = this.values,\n valcount = values.length,\n xvalues = this.xvalues,\n yvalues = this.yvalues,\n yminmax = this.yminmax,\n i, val, isStr, isArray, sp;\n for (i = 0; i < valcount; i++) {\n val = values[i];\n isStr = typeof(values[i]) === 'string';\n isArray = typeof(values[i]) === 'object' && values[i] instanceof Array;\n sp = isStr && values[i].split(':');\n if (isStr && sp.length === 2) { // x:y\n xvalues.push(Number(sp[0]));\n yvalues.push(Number(sp[1]));\n yminmax.push(Number(sp[1]));\n } else if (isArray) {\n xvalues.push(val[0]);\n yvalues.push(val[1]);\n yminmax.push(val[1]);\n } else {\n xvalues.push(i);\n if (values[i] === null || values[i] === 'null') {\n yvalues.push(null);\n } else {\n yvalues.push(Number(val));\n yminmax.push(Number(val));\n }\n }\n }\n if (this.options.get('xvalues')) {\n xvalues = this.options.get('xvalues');\n }\n\n this.maxy = this.maxyorg = Math.max.apply(Math, yminmax);\n this.miny = this.minyorg = Math.min.apply(Math, yminmax);\n\n this.maxx = Math.max.apply(Math, xvalues);\n this.minx = Math.min.apply(Math, xvalues);\n\n this.xvalues = xvalues;\n this.yvalues = yvalues;\n this.yminmax = yminmax;\n\n },\n\n processRangeOptions: function () {\n var options = this.options,\n normalRangeMin = options.get('normalRangeMin'),\n normalRangeMax = options.get('normalRangeMax');\n\n if (normalRangeMin !== undefined) {\n if (normalRangeMin < this.miny) {\n this.miny = normalRangeMin;\n }\n if (normalRangeMax > this.maxy) {\n this.maxy = normalRangeMax;\n }\n }\n if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < this.miny)) {\n this.miny = options.get('chartRangeMin');\n }\n if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > this.maxy)) {\n this.maxy = options.get('chartRangeMax');\n }\n if (options.get('chartRangeMinX') !== undefined && (options.get('chartRangeClipX') || options.get('chartRangeMinX') < this.minx)) {\n this.minx = options.get('chartRangeMinX');\n }\n if (options.get('chartRangeMaxX') !== undefined && (options.get('chartRangeClipX') || options.get('chartRangeMaxX') > this.maxx)) {\n this.maxx = options.get('chartRangeMaxX');\n }\n\n },\n\n drawNormalRange: function (canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey) {\n var normalRangeMin = this.options.get('normalRangeMin'),\n normalRangeMax = this.options.get('normalRangeMax'),\n ytop = canvasTop + Math.round(canvasHeight - (canvasHeight * ((normalRangeMax - this.miny) / rangey))),\n height = Math.round((canvasHeight * (normalRangeMax - normalRangeMin)) / rangey);\n this.target.drawRect(canvasLeft, ytop, canvasWidth, height, undefined, this.options.get('normalRangeColor')).append();\n },\n\n render: function () {\n var options = this.options,\n target = this.target,\n canvasWidth = this.canvasWidth,\n canvasHeight = this.canvasHeight,\n vertices = this.vertices,\n spotRadius = options.get('spotRadius'),\n regionMap = this.regionMap,\n rangex, rangey, yvallast,\n canvasTop, canvasLeft,\n vertex, path, paths, x, y, xnext, xpos, xposnext,\n last, next, yvalcount, lineShapes, fillShapes, plen,\n valueSpots, hlSpotsEnabled, color, xvalues, yvalues, i;\n\n if (!line._super.render.call(this)) {\n return;\n }\n\n this.scanValues();\n this.processRangeOptions();\n\n xvalues = this.xvalues;\n yvalues = this.yvalues;\n\n if (!this.yminmax.length || this.yvalues.length < 2) {\n // empty or all null valuess\n return;\n }\n\n canvasTop = canvasLeft = 0;\n\n rangex = this.maxx - this.minx === 0 ? 1 : this.maxx - this.minx;\n rangey = this.maxy - this.miny === 0 ? 1 : this.maxy - this.miny;\n yvallast = this.yvalues.length - 1;\n\n if (spotRadius && (canvasWidth < (spotRadius * 4) || canvasHeight < (spotRadius * 4))) {\n spotRadius = 0;\n }\n if (spotRadius) {\n // adjust the canvas size as required so that spots will fit\n hlSpotsEnabled = options.get('highlightSpotColor') && !options.get('disableInteraction');\n if (hlSpotsEnabled || options.get('minSpotColor') || (options.get('spotColor') && yvalues[yvallast] === this.miny)) {\n canvasHeight -= Math.ceil(spotRadius);\n }\n if (hlSpotsEnabled || options.get('maxSpotColor') || (options.get('spotColor') && yvalues[yvallast] === this.maxy)) {\n canvasHeight -= Math.ceil(spotRadius);\n canvasTop += Math.ceil(spotRadius);\n }\n if (hlSpotsEnabled ||\n ((options.get('minSpotColor') || options.get('maxSpotColor')) && (yvalues[0] === this.miny || yvalues[0] === this.maxy))) {\n canvasLeft += Math.ceil(spotRadius);\n canvasWidth -= Math.ceil(spotRadius);\n }\n if (hlSpotsEnabled || options.get('spotColor') ||\n (options.get('minSpotColor') || options.get('maxSpotColor') &&\n (yvalues[yvallast] === this.miny || yvalues[yvallast] === this.maxy))) {\n canvasWidth -= Math.ceil(spotRadius);\n }\n }\n\n\n canvasHeight--;\n\n if (options.get('normalRangeMin') !== undefined && !options.get('drawNormalOnTop')) {\n this.drawNormalRange(canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey);\n }\n\n path = [];\n paths = [path];\n last = next = null;\n yvalcount = yvalues.length;\n for (i = 0; i < yvalcount; i++) {\n x = xvalues[i];\n xnext = xvalues[i + 1];\n y = yvalues[i];\n xpos = canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex));\n xposnext = i < yvalcount - 1 ? canvasLeft + Math.round((xnext - this.minx) * (canvasWidth / rangex)) : canvasWidth;\n next = xpos + ((xposnext - xpos) / 2);\n regionMap[i] = [last || 0, next, i];\n last = next;\n if (y === null) {\n if (i) {\n if (yvalues[i - 1] !== null) {\n path = [];\n paths.push(path);\n }\n vertices.push(null);\n }\n } else {\n if (y < this.miny) {\n y = this.miny;\n }\n if (y > this.maxy) {\n y = this.maxy;\n }\n if (!path.length) {\n // previous value was null\n path.push([xpos, canvasTop + canvasHeight]);\n }\n vertex = [xpos, canvasTop + Math.round(canvasHeight - (canvasHeight * ((y - this.miny) / rangey)))];\n path.push(vertex);\n vertices.push(vertex);\n }\n }\n\n lineShapes = [];\n fillShapes = [];\n plen = paths.length;\n for (i = 0; i < plen; i++) {\n path = paths[i];\n if (path.length) {\n if (options.get('fillColor')) {\n path.push([path[path.length - 1][0], (canvasTop + canvasHeight)]);\n fillShapes.push(path.slice(0));\n path.pop();\n }\n // if there's only a single point in this path, then we want to display it\n // as a vertical line which means we keep path[0] as is\n if (path.length > 2) {\n // else we want the first value\n path[0] = [path[0][0], path[1][1]];\n }\n lineShapes.push(path);\n }\n }\n\n // draw the fill first, then optionally the normal range, then the line on top of that\n plen = fillShapes.length;\n for (i = 0; i < plen; i++) {\n target.drawShape(fillShapes[i],\n options.get('fillColor'), options.get('fillColor')).append();\n }\n\n if (options.get('normalRangeMin') !== undefined && options.get('drawNormalOnTop')) {\n this.drawNormalRange(canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey);\n }\n\n plen = lineShapes.length;\n for (i = 0; i < plen; i++) {\n target.drawShape(lineShapes[i], options.get('lineColor'), undefined,\n options.get('lineWidth')).append();\n }\n\n if (spotRadius && options.get('valueSpots')) {\n valueSpots = options.get('valueSpots');\n if (valueSpots.get === undefined) {\n valueSpots = new RangeMap(valueSpots);\n }\n for (i = 0; i < yvalcount; i++) {\n color = valueSpots.get(yvalues[i]);\n if (color) {\n target.drawCircle(canvasLeft + Math.round((xvalues[i] - this.minx) * (canvasWidth / rangex)),\n canvasTop + Math.round(canvasHeight - (canvasHeight * ((yvalues[i] - this.miny) / rangey))),\n spotRadius, undefined,\n color).append();\n }\n }\n\n }\n if (spotRadius && options.get('spotColor') && yvalues[yvallast] !== null) {\n target.drawCircle(canvasLeft + Math.round((xvalues[xvalues.length - 1] - this.minx) * (canvasWidth / rangex)),\n canvasTop + Math.round(canvasHeight - (canvasHeight * ((yvalues[yvallast] - this.miny) / rangey))),\n spotRadius, undefined,\n options.get('spotColor')).append();\n }\n if (this.maxy !== this.minyorg) {\n if (spotRadius && options.get('minSpotColor')) {\n x = xvalues[$.inArray(this.minyorg, yvalues)];\n target.drawCircle(canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex)),\n canvasTop + Math.round(canvasHeight - (canvasHeight * ((this.minyorg - this.miny) / rangey))),\n spotRadius, undefined,\n options.get('minSpotColor')).append();\n }\n if (spotRadius && options.get('maxSpotColor')) {\n x = xvalues[$.inArray(this.maxyorg, yvalues)];\n target.drawCircle(canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex)),\n canvasTop + Math.round(canvasHeight - (canvasHeight * ((this.maxyorg - this.miny) / rangey))),\n spotRadius, undefined,\n options.get('maxSpotColor')).append();\n }\n }\n\n this.lastShapeId = target.getLastShapeId();\n this.canvasTop = canvasTop;\n target.render();\n }\n });\n\n /**\n * Bar charts\n */\n $.fn.sparkline.bar = bar = createClass($.fn.sparkline._base, barHighlightMixin, {\n type: 'bar',\n\n init: function (el, values, options, width, height) {\n var barWidth = parseInt(options.get('barWidth'), 10),\n barSpacing = parseInt(options.get('barSpacing'), 10),\n chartRangeMin = options.get('chartRangeMin'),\n chartRangeMax = options.get('chartRangeMax'),\n chartRangeClip = options.get('chartRangeClip'),\n stackMin = Infinity,\n stackMax = -Infinity,\n isStackString, groupMin, groupMax, stackRanges,\n numValues, i, vlen, range, zeroAxis, xaxisOffset, min, max, clipMin, clipMax,\n stacked, vlist, j, slen, svals, val, yoffset, yMaxCalc, canvasHeightEf;\n bar._super.init.call(this, el, values, options, width, height);\n\n // scan values to determine whether to stack bars\n for (i = 0, vlen = values.length; i < vlen; i++) {\n val = values[i];\n isStackString = typeof(val) === 'string' && val.indexOf(':') > -1;\n if (isStackString || $.isArray(val)) {\n stacked = true;\n if (isStackString) {\n val = values[i] = normalizeValues(val.split(':'));\n }\n val = remove(val, null); // min/max will treat null as zero\n groupMin = Math.min.apply(Math, val);\n groupMax = Math.max.apply(Math, val);\n if (groupMin < stackMin) {\n stackMin = groupMin;\n }\n if (groupMax > stackMax) {\n stackMax = groupMax;\n }\n }\n }\n\n this.stacked = stacked;\n this.regionShapes = {};\n this.barWidth = barWidth;\n this.barSpacing = barSpacing;\n this.totalBarWidth = barWidth + barSpacing;\n this.width = width = (values.length * barWidth) + ((values.length - 1) * barSpacing);\n\n this.initTarget();\n\n if (chartRangeClip) {\n clipMin = chartRangeMin === undefined ? -Infinity : chartRangeMin;\n clipMax = chartRangeMax === undefined ? Infinity : chartRangeMax;\n }\n\n numValues = [];\n stackRanges = stacked ? [] : numValues;\n var stackTotals = [];\n var stackRangesNeg = [];\n for (i = 0, vlen = values.length; i < vlen; i++) {\n if (stacked) {\n vlist = values[i];\n values[i] = svals = [];\n stackTotals[i] = 0;\n stackRanges[i] = stackRangesNeg[i] = 0;\n for (j = 0, slen = vlist.length; j < slen; j++) {\n val = svals[j] = chartRangeClip ? clipval(vlist[j], clipMin, clipMax) : vlist[j];\n if (val !== null) {\n if (val > 0) {\n stackTotals[i] += val;\n }\n if (stackMin < 0 && stackMax > 0) {\n if (val < 0) {\n stackRangesNeg[i] += Math.abs(val);\n } else {\n stackRanges[i] += val;\n }\n } else {\n stackRanges[i] += Math.abs(val - (val < 0 ? stackMax : stackMin));\n }\n numValues.push(val);\n }\n }\n } else {\n val = chartRangeClip ? clipval(values[i], clipMin, clipMax) : values[i];\n val = values[i] = normalizeValue(val);\n if (val !== null) {\n numValues.push(val);\n }\n }\n }\n this.max = max = Math.max.apply(Math, numValues);\n this.min = min = Math.min.apply(Math, numValues);\n this.stackMax = stackMax = stacked ? Math.max.apply(Math, stackTotals) : max;\n this.stackMin = stackMin = stacked ? Math.min.apply(Math, numValues) : min;\n\n if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < min)) {\n min = options.get('chartRangeMin');\n }\n if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > max)) {\n max = options.get('chartRangeMax');\n }\n\n this.zeroAxis = zeroAxis = options.get('zeroAxis', true);\n if (min <= 0 && max >= 0 && zeroAxis) {\n xaxisOffset = 0;\n } else if (zeroAxis == false) {\n xaxisOffset = min;\n } else if (min > 0) {\n xaxisOffset = min;\n } else {\n xaxisOffset = max;\n }\n this.xaxisOffset = xaxisOffset;\n\n range = stacked ? (Math.max.apply(Math, stackRanges) + Math.max.apply(Math, stackRangesNeg)) : max - min;\n\n // as we plot zero/min values a single pixel line, we add a pixel to all other\n // values - Reduce the effective canvas size to suit\n this.canvasHeightEf = (zeroAxis && min < 0) ? this.canvasHeight - 2 : this.canvasHeight - 1;\n\n if (min < xaxisOffset) {\n yMaxCalc = (stacked && max >= 0) ? stackMax : max;\n yoffset = (yMaxCalc - xaxisOffset) / range * this.canvasHeight;\n if (yoffset !== Math.ceil(yoffset)) {\n this.canvasHeightEf -= 2;\n yoffset = Math.ceil(yoffset);\n }\n } else {\n yoffset = this.canvasHeight;\n }\n this.yoffset = yoffset;\n\n if ($.isArray(options.get('colorMap'))) {\n this.colorMapByIndex = options.get('colorMap');\n this.colorMapByValue = null;\n } else {\n this.colorMapByIndex = null;\n this.colorMapByValue = options.get('colorMap');\n if (this.colorMapByValue && this.colorMapByValue.get === undefined) {\n this.colorMapByValue = new RangeMap(this.colorMapByValue);\n }\n }\n\n this.range = range;\n },\n\n getRegion: function (el, x, y) {\n var result = Math.floor(x / this.totalBarWidth);\n return (result < 0 || result >= this.values.length) ? undefined : result;\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion,\n values = ensureArray(this.values[currentRegion]),\n result = [],\n value, i;\n for (i = values.length; i--;) {\n value = values[i];\n result.push({\n isNull: value === null,\n value: value,\n color: this.calcColor(i, value, currentRegion),\n offset: currentRegion\n });\n }\n return result;\n },\n\n calcColor: function (stacknum, value, valuenum) {\n var colorMapByIndex = this.colorMapByIndex,\n colorMapByValue = this.colorMapByValue,\n options = this.options,\n color, newColor;\n if (this.stacked) {\n color = options.get('stackedBarColor');\n } else {\n color = (value < 0) ? options.get('negBarColor') : options.get('barColor');\n }\n if (value === 0 && options.get('zeroColor') !== undefined) {\n color = options.get('zeroColor');\n }\n if (colorMapByValue && (newColor = colorMapByValue.get(value))) {\n color = newColor;\n } else if (colorMapByIndex && colorMapByIndex.length > valuenum) {\n color = colorMapByIndex[valuenum];\n }\n return $.isArray(color) ? color[stacknum % color.length] : color;\n },\n\n /**\n * Render bar(s) for a region\n */\n renderRegion: function (valuenum, highlight) {\n var vals = this.values[valuenum],\n options = this.options,\n xaxisOffset = this.xaxisOffset,\n result = [],\n range = this.range,\n stacked = this.stacked,\n target = this.target,\n x = valuenum * this.totalBarWidth,\n canvasHeightEf = this.canvasHeightEf,\n yoffset = this.yoffset,\n y, height, color, isNull, yoffsetNeg, i, valcount, val, minPlotted, allMin;\n\n vals = $.isArray(vals) ? vals : [vals];\n valcount = vals.length;\n val = vals[0];\n isNull = all(null, vals);\n allMin = all(xaxisOffset, vals, true);\n\n if (isNull) {\n if (options.get('nullColor')) {\n color = highlight ? options.get('nullColor') : this.calcHighlightColor(options.get('nullColor'), options);\n y = (yoffset > 0) ? yoffset - 1 : yoffset;\n return target.drawRect(x, y, this.barWidth - 1, 0, color, color);\n } else {\n return undefined;\n }\n }\n yoffsetNeg = yoffset;\n for (i = 0; i < valcount; i++) {\n val = vals[i];\n\n if (stacked && val === xaxisOffset) {\n if (!allMin || minPlotted) {\n continue;\n }\n minPlotted = true;\n }\n\n if (range > 0) {\n height = Math.floor(canvasHeightEf * ((Math.abs(val - xaxisOffset) / range))) + 1;\n } else {\n height = 1;\n }\n if (val < xaxisOffset || (val === xaxisOffset && yoffset === 0)) {\n y = yoffsetNeg;\n yoffsetNeg += height;\n } else {\n y = yoffset - height;\n yoffset -= height;\n }\n color = this.calcColor(i, val, valuenum);\n if (highlight) {\n color = this.calcHighlightColor(color, options);\n }\n result.push(target.drawRect(x, y, this.barWidth - 1, height - 1, color, color));\n }\n if (result.length === 1) {\n return result[0];\n }\n return result;\n }\n });\n\n /**\n * Tristate charts\n */\n $.fn.sparkline.tristate = tristate = createClass($.fn.sparkline._base, barHighlightMixin, {\n type: 'tristate',\n\n init: function (el, values, options, width, height) {\n var barWidth = parseInt(options.get('barWidth'), 10),\n barSpacing = parseInt(options.get('barSpacing'), 10);\n tristate._super.init.call(this, el, values, options, width, height);\n\n this.regionShapes = {};\n this.barWidth = barWidth;\n this.barSpacing = barSpacing;\n this.totalBarWidth = barWidth + barSpacing;\n this.values = $.map(values, Number);\n this.width = width = (values.length * barWidth) + ((values.length - 1) * barSpacing);\n\n if ($.isArray(options.get('colorMap'))) {\n this.colorMapByIndex = options.get('colorMap');\n this.colorMapByValue = null;\n } else {\n this.colorMapByIndex = null;\n this.colorMapByValue = options.get('colorMap');\n if (this.colorMapByValue && this.colorMapByValue.get === undefined) {\n this.colorMapByValue = new RangeMap(this.colorMapByValue);\n }\n }\n this.initTarget();\n },\n\n getRegion: function (el, x, y) {\n return Math.floor(x / this.totalBarWidth);\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n isNull: this.values[currentRegion] === undefined,\n value: this.values[currentRegion],\n color: this.calcColor(this.values[currentRegion], currentRegion),\n offset: currentRegion\n };\n },\n\n calcColor: function (value, valuenum) {\n var values = this.values,\n options = this.options,\n colorMapByIndex = this.colorMapByIndex,\n colorMapByValue = this.colorMapByValue,\n color, newColor;\n\n if (colorMapByValue && (newColor = colorMapByValue.get(value))) {\n color = newColor;\n } else if (colorMapByIndex && colorMapByIndex.length > valuenum) {\n color = colorMapByIndex[valuenum];\n } else if (values[valuenum] < 0) {\n color = options.get('negBarColor');\n } else if (values[valuenum] > 0) {\n color = options.get('posBarColor');\n } else {\n color = options.get('zeroBarColor');\n }\n return color;\n },\n\n renderRegion: function (valuenum, highlight) {\n var values = this.values,\n options = this.options,\n target = this.target,\n canvasHeight, height, halfHeight,\n x, y, color;\n\n canvasHeight = target.pixelHeight;\n halfHeight = Math.round(canvasHeight / 2);\n\n x = valuenum * this.totalBarWidth;\n if (values[valuenum] < 0) {\n y = halfHeight;\n height = halfHeight - 1;\n } else if (values[valuenum] > 0) {\n y = 0;\n height = halfHeight - 1;\n } else {\n y = halfHeight - 1;\n height = 2;\n }\n color = this.calcColor(values[valuenum], valuenum);\n if (color === null) {\n return;\n }\n if (highlight) {\n color = this.calcHighlightColor(color, options);\n }\n return target.drawRect(x, y, this.barWidth - 1, height - 1, color, color);\n }\n });\n\n /**\n * Discrete charts\n */\n $.fn.sparkline.discrete = discrete = createClass($.fn.sparkline._base, barHighlightMixin, {\n type: 'discrete',\n\n init: function (el, values, options, width, height) {\n discrete._super.init.call(this, el, values, options, width, height);\n\n this.regionShapes = {};\n this.values = values = $.map(values, Number);\n this.min = Math.min.apply(Math, values);\n this.max = Math.max.apply(Math, values);\n this.range = this.max - this.min;\n this.width = width = options.get('width') === 'auto' ? values.length * 2 : this.width;\n this.interval = Math.floor(width / values.length);\n this.itemWidth = width / values.length;\n if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < this.min)) {\n this.min = options.get('chartRangeMin');\n }\n if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > this.max)) {\n this.max = options.get('chartRangeMax');\n }\n this.initTarget();\n if (this.target) {\n this.lineHeight = options.get('lineHeight') === 'auto' ? Math.round(this.canvasHeight * 0.3) : options.get('lineHeight');\n }\n },\n\n getRegion: function (el, x, y) {\n return Math.floor(x / this.itemWidth);\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n isNull: this.values[currentRegion] === undefined,\n value: this.values[currentRegion],\n offset: currentRegion\n };\n },\n\n renderRegion: function (valuenum, highlight) {\n var values = this.values,\n options = this.options,\n min = this.min,\n max = this.max,\n range = this.range,\n interval = this.interval,\n target = this.target,\n canvasHeight = this.canvasHeight,\n lineHeight = this.lineHeight,\n pheight = canvasHeight - lineHeight,\n ytop, val, color, x;\n\n val = clipval(values[valuenum], min, max);\n x = valuenum * interval;\n ytop = Math.round(pheight - pheight * ((val - min) / range));\n color = (options.get('thresholdColor') && val < options.get('thresholdValue')) ? options.get('thresholdColor') : options.get('lineColor');\n if (highlight) {\n color = this.calcHighlightColor(color, options);\n }\n return target.drawLine(x, ytop, x, ytop + lineHeight, color);\n }\n });\n\n /**\n * Bullet charts\n */\n $.fn.sparkline.bullet = bullet = createClass($.fn.sparkline._base, {\n type: 'bullet',\n\n init: function (el, values, options, width, height) {\n var min, max, vals;\n bullet._super.init.call(this, el, values, options, width, height);\n\n // values: target, performance, range1, range2, range3\n this.values = values = normalizeValues(values);\n // target or performance could be null\n vals = values.slice();\n vals[0] = vals[0] === null ? vals[2] : vals[0];\n vals[1] = values[1] === null ? vals[2] : vals[1];\n min = Math.min.apply(Math, values);\n max = Math.max.apply(Math, values);\n if (options.get('base') === undefined) {\n min = min < 0 ? min : 0;\n } else {\n min = options.get('base');\n }\n this.min = min;\n this.max = max;\n this.range = max - min;\n this.shapes = {};\n this.valueShapes = {};\n this.regiondata = {};\n this.width = width = options.get('width') === 'auto' ? '4.0em' : width;\n this.target = this.$el.simpledraw(width, height, options.get('composite'));\n if (!values.length) {\n this.disabled = true;\n }\n this.initTarget();\n },\n\n getRegion: function (el, x, y) {\n var shapeid = this.target.getShapeAt(el, x, y);\n return (shapeid !== undefined && this.shapes[shapeid] !== undefined) ? this.shapes[shapeid] : undefined;\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n fieldkey: currentRegion.substr(0, 1),\n value: this.values[currentRegion.substr(1)],\n region: currentRegion\n };\n },\n\n changeHighlight: function (highlight) {\n var currentRegion = this.currentRegion,\n shapeid = this.valueShapes[currentRegion],\n shape;\n delete this.shapes[shapeid];\n switch (currentRegion.substr(0, 1)) {\n case 'r':\n shape = this.renderRange(currentRegion.substr(1), highlight);\n break;\n case 'p':\n shape = this.renderPerformance(highlight);\n break;\n case 't':\n shape = this.renderTarget(highlight);\n break;\n }\n this.valueShapes[currentRegion] = shape.id;\n this.shapes[shape.id] = currentRegion;\n this.target.replaceWithShape(shapeid, shape);\n },\n\n renderRange: function (rn, highlight) {\n var rangeval = this.values[rn],\n rangewidth = Math.round(this.canvasWidth * ((rangeval - this.min) / this.range)),\n color = this.options.get('rangeColors')[rn - 2];\n if (highlight) {\n color = this.calcHighlightColor(color, this.options);\n }\n return this.target.drawRect(0, 0, rangewidth - 1, this.canvasHeight - 1, color, color);\n },\n\n renderPerformance: function (highlight) {\n var perfval = this.values[1],\n perfwidth = Math.round(this.canvasWidth * ((perfval - this.min) / this.range)),\n color = this.options.get('performanceColor');\n if (highlight) {\n color = this.calcHighlightColor(color, this.options);\n }\n return this.target.drawRect(0, Math.round(this.canvasHeight * 0.3), perfwidth - 1,\n Math.round(this.canvasHeight * 0.4) - 1, color, color);\n },\n\n renderTarget: function (highlight) {\n var targetval = this.values[0],\n x = Math.round(this.canvasWidth * ((targetval - this.min) / this.range) - (this.options.get('targetWidth') / 2)),\n targettop = Math.round(this.canvasHeight * 0.10),\n targetheight = this.canvasHeight - (targettop * 2),\n color = this.options.get('targetColor');\n if (highlight) {\n color = this.calcHighlightColor(color, this.options);\n }\n return this.target.drawRect(x, targettop, this.options.get('targetWidth') - 1, targetheight - 1, color, color);\n },\n\n render: function () {\n var vlen = this.values.length,\n target = this.target,\n i, shape;\n if (!bullet._super.render.call(this)) {\n return;\n }\n for (i = 2; i < vlen; i++) {\n shape = this.renderRange(i).append();\n this.shapes[shape.id] = 'r' + i;\n this.valueShapes['r' + i] = shape.id;\n }\n if (this.values[1] !== null) {\n shape = this.renderPerformance().append();\n this.shapes[shape.id] = 'p1';\n this.valueShapes.p1 = shape.id;\n }\n if (this.values[0] !== null) {\n shape = this.renderTarget().append();\n this.shapes[shape.id] = 't0';\n this.valueShapes.t0 = shape.id;\n }\n target.render();\n }\n });\n\n /**\n * Pie charts\n */\n $.fn.sparkline.pie = pie = createClass($.fn.sparkline._base, {\n type: 'pie',\n\n init: function (el, values, options, width, height) {\n var total = 0, i;\n\n pie._super.init.call(this, el, values, options, width, height);\n\n this.shapes = {}; // map shape ids to value offsets\n this.valueShapes = {}; // maps value offsets to shape ids\n this.values = values = $.map(values, Number);\n\n if (options.get('width') === 'auto') {\n this.width = this.height;\n }\n\n if (values.length > 0) {\n for (i = values.length; i--;) {\n total += values[i];\n }\n }\n this.total = total;\n this.initTarget();\n this.radius = Math.floor(Math.min(this.canvasWidth, this.canvasHeight) / 2);\n },\n\n getRegion: function (el, x, y) {\n var shapeid = this.target.getShapeAt(el, x, y);\n return (shapeid !== undefined && this.shapes[shapeid] !== undefined) ? this.shapes[shapeid] : undefined;\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n isNull: this.values[currentRegion] === undefined,\n value: this.values[currentRegion],\n percent: this.values[currentRegion] / this.total * 100,\n color: this.options.get('sliceColors')[currentRegion % this.options.get('sliceColors').length],\n offset: currentRegion\n };\n },\n\n changeHighlight: function (highlight) {\n var currentRegion = this.currentRegion,\n newslice = this.renderSlice(currentRegion, highlight),\n shapeid = this.valueShapes[currentRegion];\n delete this.shapes[shapeid];\n this.target.replaceWithShape(shapeid, newslice);\n this.valueShapes[currentRegion] = newslice.id;\n this.shapes[newslice.id] = currentRegion;\n },\n\n renderSlice: function (valuenum, highlight) {\n var target = this.target,\n options = this.options,\n radius = this.radius,\n borderWidth = options.get('borderWidth'),\n offset = options.get('offset'),\n circle = 2 * Math.PI,\n values = this.values,\n total = this.total,\n next = offset ? (2*Math.PI)*(offset/360) : 0,\n start, end, i, vlen, color;\n\n vlen = values.length;\n for (i = 0; i < vlen; i++) {\n start = next;\n end = next;\n if (total > 0) { // avoid divide by zero\n end = next + (circle * (values[i] / total));\n }\n if (valuenum === i) {\n color = options.get('sliceColors')[i % options.get('sliceColors').length];\n if (highlight) {\n color = this.calcHighlightColor(color, options);\n }\n\n return target.drawPieSlice(radius, radius, radius - borderWidth, start, end, undefined, color);\n }\n next = end;\n }\n },\n\n render: function () {\n var target = this.target,\n values = this.values,\n options = this.options,\n radius = this.radius,\n borderWidth = options.get('borderWidth'),\n donutWidth = options.get('donutWidth'),\n shape, i;\n\n if (!pie._super.render.call(this)) {\n return;\n }\n if (borderWidth) {\n target.drawCircle(radius, radius, Math.floor(radius - (borderWidth / 2)),\n options.get('borderColor'), undefined, borderWidth).append();\n }\n for (i = values.length; i--;) {\n if (values[i]) { // don't render zero values\n shape = this.renderSlice(i).append();\n this.valueShapes[i] = shape.id; // store just the shapeid\n this.shapes[shape.id] = i;\n }\n }\n if (donutWidth) {\n target.drawCircle(radius, radius, radius - donutWidth, options.get('donutColor'), \n options.get('donutColor'), 0).append();\n }\n target.render();\n }\n });\n\n /**\n * Box plots\n */\n $.fn.sparkline.box = box = createClass($.fn.sparkline._base, {\n type: 'box',\n\n init: function (el, values, options, width, height) {\n box._super.init.call(this, el, values, options, width, height);\n this.values = $.map(values, Number);\n this.width = options.get('width') === 'auto' ? '4.0em' : width;\n this.initTarget();\n if (!this.values.length) {\n this.disabled = 1;\n }\n },\n\n /**\n * Simulate a single region\n */\n getRegion: function () {\n return 1;\n },\n\n getCurrentRegionFields: function () {\n var result = [\n { field: 'lq', value: this.quartiles[0] },\n { field: 'med', value: this.quartiles[1] },\n { field: 'uq', value: this.quartiles[2] }\n ];\n if (this.loutlier !== undefined) {\n result.push({ field: 'lo', value: this.loutlier});\n }\n if (this.routlier !== undefined) {\n result.push({ field: 'ro', value: this.routlier});\n }\n if (this.lwhisker !== undefined) {\n result.push({ field: 'lw', value: this.lwhisker});\n }\n if (this.rwhisker !== undefined) {\n result.push({ field: 'rw', value: this.rwhisker});\n }\n return result;\n },\n\n render: function () {\n var target = this.target,\n values = this.values,\n vlen = values.length,\n options = this.options,\n canvasWidth = this.canvasWidth,\n canvasHeight = this.canvasHeight,\n minValue = options.get('chartRangeMin') === undefined ? Math.min.apply(Math, values) : options.get('chartRangeMin'),\n maxValue = options.get('chartRangeMax') === undefined ? Math.max.apply(Math, values) : options.get('chartRangeMax'),\n canvasLeft = 0,\n lwhisker, loutlier, iqr, q1, q2, q3, rwhisker, routlier, i,\n size, unitSize;\n\n if (!box._super.render.call(this)) {\n return;\n }\n\n if (options.get('raw')) {\n if (options.get('showOutliers') && values.length > 5) {\n loutlier = values[0];\n lwhisker = values[1];\n q1 = values[2];\n q2 = values[3];\n q3 = values[4];\n rwhisker = values[5];\n routlier = values[6];\n } else {\n lwhisker = values[0];\n q1 = values[1];\n q2 = values[2];\n q3 = values[3];\n rwhisker = values[4];\n }\n } else {\n values.sort(function (a, b) { return a - b; });\n q1 = quartile(values, 1);\n q2 = quartile(values, 2);\n q3 = quartile(values, 3);\n iqr = q3 - q1;\n if (options.get('showOutliers')) {\n lwhisker = rwhisker = undefined;\n for (i = 0; i < vlen; i++) {\n if (lwhisker === undefined && values[i] > q1 - (iqr * options.get('outlierIQR'))) {\n lwhisker = values[i];\n }\n if (values[i] < q3 + (iqr * options.get('outlierIQR'))) {\n rwhisker = values[i];\n }\n }\n loutlier = values[0];\n routlier = values[vlen - 1];\n } else {\n lwhisker = values[0];\n rwhisker = values[vlen - 1];\n }\n }\n this.quartiles = [q1, q2, q3];\n this.lwhisker = lwhisker;\n this.rwhisker = rwhisker;\n this.loutlier = loutlier;\n this.routlier = routlier;\n\n unitSize = canvasWidth / (maxValue - minValue + 1);\n if (options.get('showOutliers')) {\n canvasLeft = Math.ceil(options.get('spotRadius'));\n canvasWidth -= 2 * Math.ceil(options.get('spotRadius'));\n unitSize = canvasWidth / (maxValue - minValue + 1);\n if (loutlier < lwhisker) {\n target.drawCircle((loutlier - minValue) * unitSize + canvasLeft,\n canvasHeight / 2,\n options.get('spotRadius'),\n options.get('outlierLineColor'),\n options.get('outlierFillColor')).append();\n }\n if (routlier > rwhisker) {\n target.drawCircle((routlier - minValue) * unitSize + canvasLeft,\n canvasHeight / 2,\n options.get('spotRadius'),\n options.get('outlierLineColor'),\n options.get('outlierFillColor')).append();\n }\n }\n\n // box\n target.drawRect(\n Math.round((q1 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight * 0.1),\n Math.round((q3 - q1) * unitSize),\n Math.round(canvasHeight * 0.8),\n options.get('boxLineColor'),\n options.get('boxFillColor')).append();\n // left whisker\n target.drawLine(\n Math.round((lwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 2),\n Math.round((q1 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 2),\n options.get('lineColor')).append();\n target.drawLine(\n Math.round((lwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 4),\n Math.round((lwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight - canvasHeight / 4),\n options.get('whiskerColor')).append();\n // right whisker\n target.drawLine(Math.round((rwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 2),\n Math.round((q3 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 2),\n options.get('lineColor')).append();\n target.drawLine(\n Math.round((rwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 4),\n Math.round((rwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight - canvasHeight / 4),\n options.get('whiskerColor')).append();\n // median line\n target.drawLine(\n Math.round((q2 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight * 0.1),\n Math.round((q2 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight * 0.9),\n options.get('medianColor')).append();\n if (options.get('target')) {\n size = Math.ceil(options.get('spotRadius'));\n target.drawLine(\n Math.round((options.get('target') - minValue) * unitSize + canvasLeft),\n Math.round((canvasHeight / 2) - size),\n Math.round((options.get('target') - minValue) * unitSize + canvasLeft),\n Math.round((canvasHeight / 2) + size),\n options.get('targetColor')).append();\n target.drawLine(\n Math.round((options.get('target') - minValue) * unitSize + canvasLeft - size),\n Math.round(canvasHeight / 2),\n Math.round((options.get('target') - minValue) * unitSize + canvasLeft + size),\n Math.round(canvasHeight / 2),\n options.get('targetColor')).append();\n }\n target.render();\n }\n });\n\n // Setup a very simple \"virtual canvas\" to make drawing the few shapes we need easier\n // This is accessible as $(foo).simpledraw()\n\n VShape = createClass({\n init: function (target, id, type, args) {\n this.target = target;\n this.id = id;\n this.type = type;\n this.args = args;\n },\n append: function () {\n this.target.appendShape(this);\n return this;\n }\n });\n\n VCanvas_base = createClass({\n _pxregex: /(\\d+)(px)?\\s*$/i,\n\n init: function (width, height, target) {\n if (!width) {\n return;\n }\n this.width = width;\n this.height = height;\n this.target = target;\n this.lastShapeId = null;\n if (target[0]) {\n target = target[0];\n }\n $.data(target, '_jqs_vcanvas', this);\n },\n\n drawLine: function (x1, y1, x2, y2, lineColor, lineWidth) {\n return this.drawShape([[x1, y1], [x2, y2]], lineColor, lineWidth);\n },\n\n drawShape: function (path, lineColor, fillColor, lineWidth) {\n return this._genShape('Shape', [path, lineColor, fillColor, lineWidth]);\n },\n\n drawCircle: function (x, y, radius, lineColor, fillColor, lineWidth) {\n return this._genShape('Circle', [x, y, radius, lineColor, fillColor, lineWidth]);\n },\n\n drawPieSlice: function (x, y, radius, startAngle, endAngle, lineColor, fillColor) {\n return this._genShape('PieSlice', [x, y, radius, startAngle, endAngle, lineColor, fillColor]);\n },\n\n drawRect: function (x, y, width, height, lineColor, fillColor) {\n return this._genShape('Rect', [x, y, width, height, lineColor, fillColor]);\n },\n\n getElement: function () {\n return this.canvas;\n },\n\n /**\n * Return the most recently inserted shape id\n */\n getLastShapeId: function () {\n return this.lastShapeId;\n },\n\n /**\n * Clear and reset the canvas\n */\n reset: function () {\n alert('reset not implemented');\n },\n\n _insert: function (el, target) {\n $(target).html(el);\n },\n\n /**\n * Calculate the pixel dimensions of the canvas\n */\n _calculatePixelDims: function (width, height, canvas) {\n // XXX This should probably be a configurable option\n var match;\n match = this._pxregex.exec(height);\n if (match) {\n this.pixelHeight = match[1];\n } else {\n this.pixelHeight = $(canvas).height();\n }\n match = this._pxregex.exec(width);\n if (match) {\n this.pixelWidth = match[1];\n } else {\n this.pixelWidth = $(canvas).width();\n }\n },\n\n /**\n * Generate a shape object and id for later rendering\n */\n _genShape: function (shapetype, shapeargs) {\n var id = shapeCount++;\n shapeargs.unshift(id);\n return new VShape(this, id, shapetype, shapeargs);\n },\n\n /**\n * Add a shape to the end of the render queue\n */\n appendShape: function (shape) {\n alert('appendShape not implemented');\n },\n\n /**\n * Replace one shape with another\n */\n replaceWithShape: function (shapeid, shape) {\n alert('replaceWithShape not implemented');\n },\n\n /**\n * Insert one shape after another in the render queue\n */\n insertAfterShape: function (shapeid, shape) {\n alert('insertAfterShape not implemented');\n },\n\n /**\n * Remove a shape from the queue\n */\n removeShapeId: function (shapeid) {\n alert('removeShapeId not implemented');\n },\n\n /**\n * Find a shape at the specified x/y co-ordinates\n */\n getShapeAt: function (el, x, y) {\n alert('getShapeAt not implemented');\n },\n\n /**\n * Render all queued shapes onto the canvas\n */\n render: function () {\n alert('render not implemented');\n }\n });\n\n VCanvas_canvas = createClass(VCanvas_base, {\n init: function (width, height, target, interact) {\n VCanvas_canvas._super.init.call(this, width, height, target);\n this.canvas = document.createElement('canvas');\n if (target[0]) {\n target = target[0];\n }\n $.data(target, '_jqs_vcanvas', this);\n $(this.canvas).css({ display: 'inline-block', width: width, height: height, verticalAlign: 'top' });\n this._insert(this.canvas, target);\n this._calculatePixelDims(width, height, this.canvas);\n this.canvas.width = this.pixelWidth;\n this.canvas.height = this.pixelHeight;\n this.interact = interact;\n this.shapes = {};\n this.shapeseq = [];\n this.currentTargetShapeId = undefined;\n $(this.canvas).css({width: this.pixelWidth, height: this.pixelHeight});\n },\n\n _getContext: function (lineColor, fillColor, lineWidth) {\n var context = this.canvas.getContext('2d');\n if (lineColor !== undefined) {\n context.strokeStyle = lineColor;\n }\n context.lineWidth = lineWidth === undefined ? 1 : lineWidth;\n if (fillColor !== undefined) {\n context.fillStyle = fillColor;\n }\n return context;\n },\n\n reset: function () {\n var context = this._getContext();\n context.clearRect(0, 0, this.pixelWidth, this.pixelHeight);\n this.shapes = {};\n this.shapeseq = [];\n this.currentTargetShapeId = undefined;\n },\n\n _drawShape: function (shapeid, path, lineColor, fillColor, lineWidth) {\n var context = this._getContext(lineColor, fillColor, lineWidth),\n i, plen;\n context.beginPath();\n context.moveTo(path[0][0] + 0.5, path[0][1] + 0.5);\n for (i = 1, plen = path.length; i < plen; i++) {\n context.lineTo(path[i][0] + 0.5, path[i][1] + 0.5); // the 0.5 offset gives us crisp pixel-width lines\n }\n if (lineColor !== undefined) {\n context.stroke();\n }\n if (fillColor !== undefined) {\n context.fill();\n }\n if (this.targetX !== undefined && this.targetY !== undefined &&\n context.isPointInPath(this.targetX, this.targetY)) {\n this.currentTargetShapeId = shapeid;\n }\n },\n\n _drawCircle: function (shapeid, x, y, radius, lineColor, fillColor, lineWidth) {\n var context = this._getContext(lineColor, fillColor, lineWidth);\n context.beginPath();\n context.arc(x, y, radius, 0, 2 * Math.PI, false);\n if (this.targetX !== undefined && this.targetY !== undefined &&\n context.isPointInPath(this.targetX, this.targetY)) {\n this.currentTargetShapeId = shapeid;\n }\n if (lineColor !== undefined) {\n context.stroke();\n }\n if (fillColor !== undefined) {\n context.fill();\n }\n },\n\n _drawPieSlice: function (shapeid, x, y, radius, startAngle, endAngle, lineColor, fillColor) {\n var context = this._getContext(lineColor, fillColor);\n context.beginPath();\n context.moveTo(x, y);\n context.arc(x, y, radius, startAngle, endAngle, false);\n context.lineTo(x, y);\n context.closePath();\n if (lineColor !== undefined) {\n context.stroke();\n }\n if (fillColor) {\n context.fill();\n }\n if (this.targetX !== undefined && this.targetY !== undefined &&\n context.isPointInPath(this.targetX, this.targetY)) {\n this.currentTargetShapeId = shapeid;\n }\n },\n\n _drawRect: function (shapeid, x, y, width, height, lineColor, fillColor) {\n return this._drawShape(shapeid, [[x, y], [x + width, y], [x + width, y + height], [x, y + height], [x, y]], lineColor, fillColor);\n },\n\n appendShape: function (shape) {\n this.shapes[shape.id] = shape;\n this.shapeseq.push(shape.id);\n this.lastShapeId = shape.id;\n return shape.id;\n },\n\n replaceWithShape: function (shapeid, shape) {\n var shapeseq = this.shapeseq,\n i;\n this.shapes[shape.id] = shape;\n for (i = shapeseq.length; i--;) {\n if (shapeseq[i] == shapeid) {\n shapeseq[i] = shape.id;\n }\n }\n delete this.shapes[shapeid];\n },\n\n replaceWithShapes: function (shapeids, shapes) {\n var shapeseq = this.shapeseq,\n shapemap = {},\n sid, i, first;\n\n for (i = shapeids.length; i--;) {\n shapemap[shapeids[i]] = true;\n }\n for (i = shapeseq.length; i--;) {\n sid = shapeseq[i];\n if (shapemap[sid]) {\n shapeseq.splice(i, 1);\n delete this.shapes[sid];\n first = i;\n }\n }\n for (i = shapes.length; i--;) {\n shapeseq.splice(first, 0, shapes[i].id);\n this.shapes[shapes[i].id] = shapes[i];\n }\n\n },\n\n insertAfterShape: function (shapeid, shape) {\n var shapeseq = this.shapeseq,\n i;\n for (i = shapeseq.length; i--;) {\n if (shapeseq[i] === shapeid) {\n shapeseq.splice(i + 1, 0, shape.id);\n this.shapes[shape.id] = shape;\n return;\n }\n }\n },\n\n removeShapeId: function (shapeid) {\n var shapeseq = this.shapeseq,\n i;\n for (i = shapeseq.length; i--;) {\n if (shapeseq[i] === shapeid) {\n shapeseq.splice(i, 1);\n break;\n }\n }\n delete this.shapes[shapeid];\n },\n\n getShapeAt: function (el, x, y) {\n this.targetX = x;\n this.targetY = y;\n this.render();\n return this.currentTargetShapeId;\n },\n\n render: function () {\n var shapeseq = this.shapeseq,\n shapes = this.shapes,\n shapeCount = shapeseq.length,\n context = this._getContext(),\n shapeid, shape, i;\n context.clearRect(0, 0, this.pixelWidth, this.pixelHeight);\n for (i = 0; i < shapeCount; i++) {\n shapeid = shapeseq[i];\n shape = shapes[shapeid];\n this['_draw' + shape.type].apply(this, shape.args);\n }\n if (!this.interact) {\n // not interactive so no need to keep the shapes array\n this.shapes = {};\n this.shapeseq = [];\n }\n }\n\n });\n\n VCanvas_vml = createClass(VCanvas_base, {\n init: function (width, height, target) {\n var groupel;\n VCanvas_vml._super.init.call(this, width, height, target);\n if (target[0]) {\n target = target[0];\n }\n $.data(target, '_jqs_vcanvas', this);\n this.canvas = document.createElement('span');\n $(this.canvas).css({ display: 'inline-block', position: 'relative', overflow: 'hidden', width: width, height: height, margin: '0px', padding: '0px', verticalAlign: 'top'});\n this._insert(this.canvas, target);\n this._calculatePixelDims(width, height, this.canvas);\n this.canvas.width = this.pixelWidth;\n this.canvas.height = this.pixelHeight;\n groupel = '';\n this.canvas.insertAdjacentHTML('beforeEnd', groupel);\n this.group = $(this.canvas).children()[0];\n this.rendered = false;\n this.prerender = '';\n },\n\n _drawShape: function (shapeid, path, lineColor, fillColor, lineWidth) {\n var vpath = [],\n initial, stroke, fill, closed, vel, plen, i;\n for (i = 0, plen = path.length; i < plen; i++) {\n vpath[i] = '' + (path[i][0]) + ',' + (path[i][1]);\n }\n initial = vpath.splice(0, 1);\n lineWidth = lineWidth === undefined ? 1 : lineWidth;\n stroke = lineColor === undefined ? ' stroked=\"false\" ' : ' strokeWeight=\"' + lineWidth + 'px\" strokeColor=\"' + lineColor + '\" ';\n fill = fillColor === undefined ? ' filled=\"false\"' : ' fillColor=\"' + fillColor + '\" filled=\"true\" ';\n closed = vpath[0] === vpath[vpath.length - 1] ? 'x ' : '';\n vel = '' +\n ' ';\n return vel;\n },\n\n _drawCircle: function (shapeid, x, y, radius, lineColor, fillColor, lineWidth) {\n var stroke, fill, vel;\n x -= radius;\n y -= radius;\n stroke = lineColor === undefined ? ' stroked=\"false\" ' : ' strokeWeight=\"' + lineWidth + 'px\" strokeColor=\"' + lineColor + '\" ';\n fill = fillColor === undefined ? ' filled=\"false\"' : ' fillColor=\"' + fillColor + '\" filled=\"true\" ';\n vel = '';\n return vel;\n\n },\n\n _drawPieSlice: function (shapeid, x, y, radius, startAngle, endAngle, lineColor, fillColor) {\n var vpath, startx, starty, endx, endy, stroke, fill, vel;\n if (startAngle === endAngle) {\n return ''; // VML seems to have problem when start angle equals end angle.\n }\n if ((endAngle - startAngle) === (2 * Math.PI)) {\n startAngle = 0.0; // VML seems to have a problem when drawing a full circle that doesn't start 0\n endAngle = (2 * Math.PI);\n }\n\n startx = x + Math.round(Math.cos(startAngle) * radius);\n starty = y + Math.round(Math.sin(startAngle) * radius);\n endx = x + Math.round(Math.cos(endAngle) * radius);\n endy = y + Math.round(Math.sin(endAngle) * radius);\n\n if (startx === endx && starty === endy) {\n if ((endAngle - startAngle) < Math.PI) {\n // Prevent very small slices from being mistaken as a whole pie\n return '';\n }\n // essentially going to be the entire circle, so ignore startAngle\n startx = endx = x + radius;\n starty = endy = y;\n }\n\n if (startx === endx && starty === endy && (endAngle - startAngle) < Math.PI) {\n return '';\n }\n\n vpath = [x - radius, y - radius, x + radius, y + radius, startx, starty, endx, endy];\n stroke = lineColor === undefined ? ' stroked=\"false\" ' : ' strokeWeight=\"1px\" strokeColor=\"' + lineColor + '\" ';\n fill = fillColor === undefined ? ' filled=\"false\"' : ' fillColor=\"' + fillColor + '\" filled=\"true\" ';\n vel = '' +\n ' ';\n return vel;\n },\n\n _drawRect: function (shapeid, x, y, width, height, lineColor, fillColor) {\n return this._drawShape(shapeid, [[x, y], [x, y + height], [x + width, y + height], [x + width, y], [x, y]], lineColor, fillColor);\n },\n\n reset: function () {\n this.group.innerHTML = '';\n },\n\n appendShape: function (shape) {\n var vel = this['_draw' + shape.type].apply(this, shape.args);\n if (this.rendered) {\n this.group.insertAdjacentHTML('beforeEnd', vel);\n } else {\n this.prerender += vel;\n }\n this.lastShapeId = shape.id;\n return shape.id;\n },\n\n replaceWithShape: function (shapeid, shape) {\n var existing = $('#jqsshape' + shapeid),\n vel = this['_draw' + shape.type].apply(this, shape.args);\n existing[0].outerHTML = vel;\n },\n\n replaceWithShapes: function (shapeids, shapes) {\n // replace the first shapeid with all the new shapes then toast the remaining old shapes\n var existing = $('#jqsshape' + shapeids[0]),\n replace = '',\n slen = shapes.length,\n i;\n for (i = 0; i < slen; i++) {\n replace += this['_draw' + shapes[i].type].apply(this, shapes[i].args);\n }\n existing[0].outerHTML = replace;\n for (i = 1; i < shapeids.length; i++) {\n $('#jqsshape' + shapeids[i]).remove();\n }\n },\n\n insertAfterShape: function (shapeid, shape) {\n var existing = $('#jqsshape' + shapeid),\n vel = this['_draw' + shape.type].apply(this, shape.args);\n existing[0].insertAdjacentHTML('afterEnd', vel);\n },\n\n removeShapeId: function (shapeid) {\n var existing = $('#jqsshape' + shapeid);\n this.group.removeChild(existing[0]);\n },\n\n getShapeAt: function (el, x, y) {\n var shapeid = el.id.substr(8);\n return shapeid;\n },\n\n render: function () {\n if (!this.rendered) {\n // batch the intial render into a single repaint\n this.group.innerHTML = this.prerender;\n this.rendered = true;\n }\n }\n });\n\n}))}(document, Math));\n", "import './vendor';\nimport 'jquery-sparkline';\nimport { authFetch } from './authWrap';\nimport { error, log } from './logger';\n\ninterface GpuInfo {\n name: string;\n data: Record;\n chart?: [number, number];\n}\n\nlet gpuInterval: ReturnType | null = null;\nconst chartData: { mem: number[]; load: number[] } = { mem: [], load: [] };\n\nasync function updateGPUChart(mem: number, load: number): Promise {\n const maxLen = 120;\n const colorRangeMap = $.range_map({\n '0:5': '#fffafa',\n '6:10': '#fff7ed',\n '11:20': '#fed7aa',\n '21:30': '#fdba74',\n '31:40': '#fb923c',\n '41:50': '#f97316',\n '51:60': '#ea580c',\n '61:70': '#c2410c',\n '71:80': '#9a3412',\n '81:90': '#7c2d12',\n '91:100': '#6c2e12',\n });\n const sparklineConfigLOAD = { type: 'bar', height: '128px', barWidth: '3px', barSpacing: '1px', chartRangeMin: 0, chartRangeMax: 100, barColor: '#89007D' };\n const sparklineConfigMEM = { type: 'bar', height: '128px', barWidth: '3px', barSpacing: '1px', chartRangeMin: 0, chartRangeMax: 100, colorMap: colorRangeMap, composite: true };\n if (chartData.load.length > maxLen) chartData.load.shift();\n chartData.load.push(load);\n if (chartData.mem.length > maxLen) chartData.mem.shift();\n chartData.mem.push(mem);\n $('#gpuChart').sparkline(chartData.load, sparklineConfigLOAD);\n $('#gpuChart').sparkline(chartData.mem, sparklineConfigMEM);\n}\n\nasync function updateGPU(): Promise {\n const gpuEl = document.getElementById('gpu');\n const gpuTable = document.getElementById('gpu-table');\n if (!gpuEl || !gpuTable) return;\n try {\n const res = await authFetch(`${window.api}/gpu-smi`);\n if (!res || !res.ok) {\n clearInterval(gpuInterval);\n gpuEl.style.display = 'none';\n return;\n }\n const data = (await res.json()) as GpuInfo[];\n if (!data) {\n clearInterval(gpuInterval);\n gpuEl.style.display = 'none';\n return;\n }\n const gpuTbody = gpuTable.querySelector('tbody');\n if (!gpuTbody) return;\n for (const gpu of data) {\n let rows = `GPU${gpu.name}`;\n for (const item of Object.entries(gpu.data)) rows += `${item[0]}${item[1]}`;\n gpuTbody.innerHTML = rows;\n if (gpu.chart && gpu.chart.length === 2) updateGPUChart(gpu.chart[0], gpu.chart[1]);\n }\n gpuEl.style.display = 'block';\n } catch (e) {\n error('updateGPU', e);\n clearInterval(gpuInterval);\n gpuEl.style.display = 'none';\n }\n}\n\nexport async function startGPU(): Promise {\n const gpuEl = document.getElementById('gpu');\n if (!gpuEl) return;\n gpuEl.style.display = 'block';\n if (gpuInterval) clearInterval(gpuInterval);\n const interval = window.opts?.gpu_monitor || 3000;\n log('startGPU', interval);\n gpuInterval = setInterval(updateGPU, interval);\n updateGPU();\n}\n\nwindow.startGPU = startGPU;\n\nexport async function disableGPU(): Promise {\n clearInterval(gpuInterval);\n const gpuEl = document.getElementById('gpu');\n if (gpuEl) gpuEl.style.display = 'none';\n}\n\nwindow.disableGPU = disableGPU;\n"], - "mappings": "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", + "sourcesContent": ["/*!\n * jQuery JavaScript Library v4.0.0\n * https://jquery.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.com/license/\n *\n * Date: 2026-01-18T00:20Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\tmodule.exports = factory( global, true );\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n\"use strict\";\n\nif ( !window.document ) {\n\tthrow new Error( \"jQuery requires a window with a document\" );\n}\n\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\n// Support: IE 11+\n// IE doesn't have Array#flat; provide a fallback.\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\n// [[Class]] -> type pairs\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\n// All support tests are defined in their respective modules.\nvar support = {};\n\nfunction toType( obj ) {\n\tif ( obj == null ) {\n\t\treturn obj + \"\";\n\t}\n\n\treturn typeof obj === \"object\" ?\n\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\ttypeof obj;\n}\n\nfunction isWindow( obj ) {\n\treturn obj != null && obj === obj.window;\n}\n\nfunction isArrayLike( obj ) {\n\n\tvar length = !!obj && obj.length,\n\t\ttype = toType( obj );\n\n\tif ( typeof obj === \"function\" || isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\n\nvar document$1 = window.document;\n\nvar preservedScriptAttributes = {\n\ttype: true,\n\tsrc: true,\n\tnonce: true,\n\tnoModule: true\n};\n\nfunction DOMEval( code, node, doc ) {\n\tdoc = doc || document$1;\n\n\tvar i,\n\t\tscript = doc.createElement( \"script\" );\n\n\tscript.text = code;\n\tfor ( i in preservedScriptAttributes ) {\n\t\tif ( node && node[ i ] ) {\n\t\t\tscript[ i ] = node[ i ];\n\t\t}\n\t}\n\n\tif ( doc.head.appendChild( script ).parentNode ) {\n\t\tscript.parentNode.removeChild( script );\n\t}\n}\n\nvar version = \"4.0.0\",\n\n\trhtmlSuffix = /HTML$/i,\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\n\t\t// Return all the elements in a clean array\n\t\tif ( num == null ) {\n\t\t\treturn slice.call( this );\n\t\t}\n\n\t\t// Return just the one element from the set\n\t\treturn num < 0 ? this[ num + this.length ] : this[ num ];\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teven: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn ( i + 1 ) % 2;\n\t\t} ) );\n\t},\n\n\todd: function() {\n\t\treturn this.pushStack( jQuery.grep( this, function( _elem, i ) {\n\t\t\treturn i % 2;\n\t\t} ) );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t}\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && typeof target !== \"function\" ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent Object.prototype pollution\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( name === \"__proto__\" || target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = Array.isArray( copy ) ) ) ) {\n\t\t\t\t\tsrc = target[ name ];\n\n\t\t\t\t\t// Ensure proper type for the source value\n\t\t\t\t\tif ( copyIsArray && !Array.isArray( src ) ) {\n\t\t\t\t\t\tclone = [];\n\t\t\t\t\t} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {\n\t\t\t\t\t\tclone = {};\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src;\n\t\t\t\t\t}\n\t\t\t\t\tcopyIsArray = false;\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisPlainObject: function( obj ) {\n\t\tvar proto, Ctor;\n\n\t\t// Detect obvious negatives\n\t\t// Use toString instead of jQuery.type to catch host objects\n\t\tif ( !obj || toString.call( obj ) !== \"[object Object]\" ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tproto = getProto( obj );\n\n\t\t// Objects with no prototype (e.g., `Object.create( null )`) are plain\n\t\tif ( !proto ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Objects with prototype are plain iff they were constructed by a global Object function\n\t\tCtor = hasOwn.call( proto, \"constructor\" ) && proto.constructor;\n\t\treturn typeof Ctor === \"function\" && fnToString.call( Ctor ) === ObjectFunctionString;\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\t// Evaluates a script in a provided context; falls back to the global one\n\t// if not specified.\n\tglobalEval: function( code, options, doc ) {\n\t\tDOMEval( code, { nonce: options && options.nonce }, doc );\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\n\t// Retrieve the text value of an array of DOM nodes\n\ttext: function( elem ) {\n\t\tvar node,\n\t\t\tret = \"\",\n\t\t\ti = 0,\n\t\t\tnodeType = elem.nodeType;\n\n\t\tif ( !nodeType ) {\n\n\t\t\t// If no nodeType, this is expected to be an array\n\t\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t\t// Do not traverse comment nodes\n\t\t\t\tret += jQuery.text( node );\n\t\t\t}\n\t\t}\n\t\tif ( nodeType === 1 || nodeType === 11 ) {\n\t\t\treturn elem.textContent;\n\t\t}\n\t\tif ( nodeType === 9 ) {\n\t\t\treturn elem.documentElement.textContent;\n\t\t}\n\t\tif ( nodeType === 3 || nodeType === 4 ) {\n\t\t\treturn elem.nodeValue;\n\t\t}\n\n\t\t// Do not include comment or processing instruction nodes\n\n\t\treturn ret;\n\t},\n\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\tisXMLDoc: function( elem ) {\n\t\tvar namespace = elem && elem.namespaceURI,\n\t\t\tdocElem = elem && ( elem.ownerDocument || elem ).documentElement;\n\n\t\t// Assume HTML when documentElement doesn't yet exist, such as inside\n\t\t// document fragments.\n\t\treturn !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n\t},\n\n\t// Note: an element does not contain itself\n\tcontains: function( a, b ) {\n\t\tvar bup = b && b.parentNode;\n\n\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\n\t\t\t// Support: IE 9 - 11+\n\t\t\t// IE doesn't have `contains` on SVG.\n\t\t\ta.contains ?\n\t\t\t\ta.contains( bup ) :\n\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t) );\n\t},\n\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn flat( ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\n\tfunction( _i, name ) {\n\t\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n\t} );\n\nfunction nodeName( elem, name ) {\n\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n}\n\nvar pop = arr.pop;\n\n// https://www.w3.org/TR/css3-selectors/#whitespace\nvar whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\";\n\nvar isIE = document$1.documentMode;\n\nvar rbuggyQSA = isIE && new RegExp(\n\n\t// Support: IE 9 - 11+\n\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\":enabled|:disabled|\" +\n\n\t// Support: IE 11+\n\t// IE 11 doesn't find elements on a `[name='']` query in some cases.\n\t// Adding a temporary attribute to the document before the selection works\n\t// around the issue.\n\t\"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\twhitespace + \"*(?:''|\\\"\\\")\"\n\n);\n\nvar rtrimCSS = new RegExp(\n\t\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\",\n\t\"g\"\n);\n\n// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\nvar identifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\";\n\nvar rleadingCombinator = new RegExp( \"^\" + whitespace + \"*([>+~]|\" +\n\twhitespace + \")\" + whitespace + \"*\" );\n\nvar rdescend = new RegExp( whitespace + \"|>\" );\n\nvar rsibling = /[+~]/;\n\nvar documentElement$1 = document$1.documentElement;\n\n// Support: IE 9 - 11+\n// IE requires a prefix.\nvar matches = documentElement$1.matches || documentElement$1.msMatchesSelector;\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\n\t\t// Use (key + \" \") to avoid collision with native prototype properties\n\t\t// (see https://github.com/jquery/sizzle/issues/157)\n\t\tif ( keys.push( key + \" \" ) > jQuery.expr.cacheLength ) {\n\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn ( cache[ key + \" \" ] = value );\n\t}\n\treturn cache;\n}\n\n/**\n * Checks a node for validity as a jQuery selector context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors\nvar attributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t// Operator (capture 2)\n\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\twhitespace + \"*\\\\]\";\n\nvar pseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n\t// 2. simple (capture 6)\n\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n\t// 3. anything else (capture 2)\n\t\".*\" +\n\t\")\\\\)|)\";\n\nvar filterMatchExpr = {\n\tID: new RegExp( \"^#(\" + identifier + \")\" ),\n\tCLASS: new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\tTAG: new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\tATTR: new RegExp( \"^\" + attributes ),\n\tPSEUDO: new RegExp( \"^\" + pseudos ),\n\tCHILD: new RegExp(\n\t\t\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" )\n};\n\nvar rpseudo = new RegExp( pseudos );\n\n// CSS escapes\n// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\nvar runescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\tif ( nonHex ) {\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\treturn nonHex;\n\t\t}\n\n\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t// Support: IE <=11+\n\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t// surrogate pair\n\t\treturn high < 0 ?\n\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t};\n\nfunction unescapeSelector( sel ) {\n\treturn sel.replace( runescape, funescape );\n}\n\nfunction selectorError( msg ) {\n\tjQuery.error( \"Syntax error, unrecognized expression: \" + msg );\n}\n\nvar rcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" );\n\nvar tokenCache = createCache();\n\nfunction tokenize( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = jQuery.expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || ( match = rcomma.exec( soFar ) ) ) {\n\t\t\tif ( match ) {\n\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[ 0 ].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( ( tokens = [] ) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( ( match = rleadingCombinator.exec( soFar ) ) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push( {\n\t\t\t\tvalue: matched,\n\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[ 0 ].replace( rtrimCSS, \" \" )\n\t\t\t} );\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in filterMatchExpr ) {\n\t\t\tif ( ( match = jQuery.expr.match[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\n\t\t\t\t( match = preFilters[ type ]( match ) ) ) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push( {\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t} );\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\tif ( parseOnly ) {\n\t\treturn soFar.length;\n\t}\n\n\treturn soFar ?\n\t\tselectorError( selector ) :\n\n\t\t// Cache the tokens\n\t\ttokenCache( selector, groups ).slice( 0 );\n}\n\nvar preFilter = {\n\tATTR: function( match ) {\n\t\tmatch[ 1 ] = unescapeSelector( match[ 1 ] );\n\n\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\tmatch[ 3 ] = unescapeSelector( match[ 3 ] || match[ 4 ] || match[ 5 ] || \"\" );\n\n\t\tif ( match[ 2 ] === \"~=\" ) {\n\t\t\tmatch[ 3 ] = \" \" + match[ 3 ] + \" \";\n\t\t}\n\n\t\treturn match.slice( 0, 4 );\n\t},\n\n\tCHILD: function( match ) {\n\n\t\t/* matches from filterMatchExpr[\"CHILD\"]\n\t\t\t1 type (only|nth|...)\n\t\t\t2 what (child|of-type)\n\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t5 sign of xn-component\n\t\t\t6 x of xn-component\n\t\t\t7 sign of y-component\n\t\t\t8 y of y-component\n\t\t*/\n\t\tmatch[ 1 ] = match[ 1 ].toLowerCase();\n\n\t\tif ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\n\n\t\t\t// nth-* requires argument\n\t\t\tif ( !match[ 3 ] ) {\n\t\t\t\tselectorError( match[ 0 ] );\n\t\t\t}\n\n\t\t\t// numeric x and y parameters for jQuery.expr.filter.CHILD\n\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\tmatch[ 4 ] = +( match[ 4 ] ?\n\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" )\n\t\t\t);\n\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t// other types prohibit arguments\n\t\t} else if ( match[ 3 ] ) {\n\t\t\tselectorError( match[ 0 ] );\n\t\t}\n\n\t\treturn match;\n\t},\n\n\tPSEUDO: function( match ) {\n\t\tvar excess,\n\t\t\tunquoted = !match[ 6 ] && match[ 2 ];\n\n\t\tif ( filterMatchExpr.CHILD.test( match[ 0 ] ) ) {\n\t\t\treturn null;\n\t\t}\n\n\t\t// Accept quoted arguments as-is\n\t\tif ( match[ 3 ] ) {\n\t\t\tmatch[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\n\n\t\t// Strip excess characters from unquoted arguments\n\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\n\t\t\t// Get excess from tokenize (recursively)\n\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\n\t\t\t// advance to the next closing parenthesis\n\t\t\t( excess = unquoted.indexOf( \")\", unquoted.length - excess ) -\n\t\t\t\tunquoted.length ) ) {\n\n\t\t\t// excess is a negative index\n\t\t\tmatch[ 0 ] = match[ 0 ].slice( 0, excess );\n\t\t\tmatch[ 2 ] = unquoted.slice( 0, excess );\n\t\t}\n\n\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\treturn match.slice( 0, 3 );\n\t}\n};\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[ i ].value;\n\t}\n\treturn selector;\n}\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nfunction access( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( toType( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( typeof value !== \"function\" ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, _key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\t\tvalue :\n\t\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( chainable ) {\n\t\treturn elems;\n\t}\n\n\t// Gets\n\tif ( bulk ) {\n\t\treturn fn.call( elems );\n\t}\n\n\treturn len ? fn( elems[ 0 ], key ) : emptyGet;\n}\n\n// Only count HTML whitespace\n// Other whitespace should count in values\n// https://infra.spec.whatwg.org/#ascii-whitespace\nvar rnothtmlwhite = /[^\\x20\\t\\r\\n\\f]+/g;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// Attribute hooks are determined by the lowercase version\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\thooks = jQuery.attrHooks[ name.toLowerCase() ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ||\n\n\t\t\t\t// For compat with previous handling of boolean attributes,\n\t\t\t\t// remove when `false` passed. For ARIA attributes -\n\t\t\t\t// many of which recognize a `\"false\"` value - continue to\n\t\t\t\t// set the `\"false\"` value as jQuery <4 did.\n\t\t\t\t( value === false && name.toLowerCase().indexOf( \"aria-\" ) !== 0 ) ) {\n\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = elem.getAttribute( name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name,\n\t\t\ti = 0,\n\n\t\t\t// Attribute names can contain non-HTML whitespace characters\n\t\t\t// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n\t\t\tattrNames = value && value.match( rnothtmlwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Support: IE <=11+\n// An input loses its value after becoming a radio\nif ( isIE ) {\n\tjQuery.attrHooks.type = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( value === \"radio\" && nodeName( elem, \"input\" ) ) {\n\t\t\t\tvar val = elem.value;\n\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\tif ( val ) {\n\t\t\t\t\telem.value = val;\n\t\t\t\t}\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\t};\n}\n\n// CSS string/identifier serialization\n// https://drafts.csswg.org/cssom/#common-serializing-idioms\nvar rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\x80-\\uFFFF\\w-]/g;\n\nfunction fcssescape( ch, asCodePoint ) {\n\tif ( asCodePoint ) {\n\n\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\tif ( ch === \"\\0\" ) {\n\t\t\treturn \"\\uFFFD\";\n\t\t}\n\n\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\treturn ch.slice( 0, -1 ) + \"\\\\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t}\n\n\t// Other potentially-special ASCII characters get backslash-escaped\n\treturn \"\\\\\" + ch;\n}\n\njQuery.escapeSelector = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\nvar sort = arr.sort;\n\nvar splice = arr.splice;\n\nvar hasDuplicate;\n\n// Document order sorting\nfunction sortOrder( a, b ) {\n\n\t// Flag for duplicate removal\n\tif ( a === b ) {\n\t\thasDuplicate = true;\n\t\treturn 0;\n\t}\n\n\t// Sort on method existence if only one input has compareDocumentPosition\n\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\tif ( compare ) {\n\t\treturn compare;\n\t}\n\n\t// Calculate position if both inputs belong to the same document\n\t// Support: IE 11+\n\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tcompare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\n\t\ta.compareDocumentPosition( b ) :\n\n\t\t// Otherwise we know they are disconnected\n\t\t1;\n\n\t// Disconnected nodes\n\tif ( compare & 1 ) {\n\n\t\t// Choose the first element that is related to the document\n\t\t// Support: IE 11+\n\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tif ( a == document$1 || a.ownerDocument == document$1 &&\n\t\t\tjQuery.contains( document$1, a ) ) {\n\t\t\treturn -1;\n\t\t}\n\n\t\t// Support: IE 11+\n\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tif ( b == document$1 || b.ownerDocument == document$1 &&\n\t\t\tjQuery.contains( document$1, b ) ) {\n\t\t\treturn 1;\n\t\t}\n\n\t\t// Maintain original order\n\t\treturn 0;\n\t}\n\n\treturn compare & 4 ? -1 : 1;\n}\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\njQuery.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\thasDuplicate = false;\n\n\tsort.call( results, sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tsplice.call( results, duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\treturn results;\n};\n\njQuery.fn.uniqueSort = function() {\n\treturn this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );\n};\n\nvar i,\n\toutermostContext,\n\n\t// Local document vars\n\tdocument,\n\tdocumentElement,\n\tdocumentIsHTML,\n\n\t// Instance-specific data\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\tcompilerCache = createCache(),\n\tnonnativeSelectorCache = createCache(),\n\n\t// Regular expressions\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = jQuery.extend( {\n\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\tneedsContext: new RegExp( \"^\" + whitespace +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t}, filterMatchExpr ),\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr$1 = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\t// Used for iframes; see `setDocument`.\n\t// Support: IE 9 - 11+\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE.\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && nodeName( elem, \"fieldset\" );\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\nfunction find( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\t\tsetDocument( context );\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && ( match = rquickExpr$1.exec( selector ) ) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( ( m = match[ 1 ] ) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( ( elem = context.getElementById( m ) ) ) {\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn results;\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\t\t\t\t\t\tif ( newContext && ( elem = newContext.getElementById( m ) ) &&\n\t\t\t\t\t\t\tjQuery.contains( context, elem ) ) {\n\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[ 2 ] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( !nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) &&\n\t\t\t\t\t\ttestContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\n\t\t\t\t\t// Outside of IE, if we're not changing the context we can\n\t\t\t\t\t// use :scope instead of an ID.\n\t\t\t\t\t// Support: IE 11+\n\t\t\t\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( newContext != context || isIE ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = jQuery.escapeSelector( nid );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = jQuery.expando ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === jQuery.expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrimCSS, \"$1\" ), context, results, seed );\n}\n\n/**\n * Mark a function for special use by jQuery selector module\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ jQuery.expando ] = true;\n\treturn fn;\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn nodeName( elem, \"input\" ) && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\treturn ( nodeName( elem, \"input\" ) || nodeName( elem, \"button\" ) ) &&\n\t\t\telem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for :enabled/:disabled\n * @param {Boolean} disabled true for :disabled; false for :enabled\n */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t// https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t// https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t// https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11+\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\t\tinDisabledFieldset( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction( function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction( function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ ( j = matchIndexes[ i ] ) ] ) {\n\t\t\t\t\tseed[ j ] = !( matches[ j ] = seed[ j ] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t} );\n}\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [node] An element or document object to use to set the document\n */\nfunction setDocument( node ) {\n\tvar subWindow,\n\t\tdoc = node ? node.ownerDocument || node : document$1;\n\n\t// Return early if doc is invalid or already selected\n\t// Support: IE 11+\n\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( doc == document || doc.nodeType !== 9 ) {\n\t\treturn;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocumentElement = document.documentElement;\n\tdocumentIsHTML = !jQuery.isXMLDoc( document );\n\n\t// Support: IE 9 - 11+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (see trac-13936)\n\t// Support: IE 11+\n\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( isIE && document$1 != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\t\tsubWindow.addEventListener( \"unload\", unloadHandler );\n\t}\n}\n\nfind.matches = function( expr, elements ) {\n\treturn find( expr, null, null, elements );\n};\n\nfind.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\treturn matches.call( elem, expr );\n\t\t} catch ( e ) {\n\t\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn find( expr, document, null, [ elem ] ).length > 0;\n};\n\njQuery.expr = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tfind: {\n\t\tID: function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t},\n\n\t\tTAG: function( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t},\n\n\t\tCLASS: function( className, context ) {\n\t\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\t\treturn context.getElementsByClassName( className );\n\t\t\t}\n\t\t}\n\t},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: preFilter,\n\n\tfilter: {\n\t\tID: function( id ) {\n\t\t\tvar attrId = unescapeSelector( id );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t},\n\n\t\tTAG: function( nodeNameSelector ) {\n\t\t\tvar expectedNodeName = unescapeSelector( nodeNameSelector ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\n\t\t\t\tfunction() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn nodeName( elem, expectedNodeName );\n\t\t\t\t};\n\t\t},\n\n\t\tCLASS: function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace + \")\" + className +\n\t\t\t\t\t\"(\" + whitespace + \"|$)\" ) ) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\tATTR: function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = jQuery.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\tif ( operator === \"=\" ) {\n\t\t\t\t\treturn result === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"!=\" ) {\n\t\t\t\t\treturn result !== check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"^=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) === 0;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"*=\" ) {\n\t\t\t\t\treturn check && result.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"$=\" ) {\n\t\t\t\t\treturn check && result.slice( -check.length ) === check;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"~=\" ) {\n\t\t\t\t\treturn ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" )\n\t\t\t\t\t\t.indexOf( check ) > -1;\n\t\t\t\t}\n\t\t\t\tif ( operator === \"|=\" ) {\n\t\t\t\t\treturn result === check || result.slice( 0, check.length + 1 ) === check + \"-\";\n\t\t\t\t}\n\n\t\t\t\treturn false;\n\t\t\t};\n\t\t},\n\n\t\tCHILD: function( type, what, _argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tvar cache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( ( node = node[ dir ] ) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\t\t\t\t\t\t\touterCache = parent[ jQuery.expando ] ||\n\t\t\t\t\t\t\t\t( parent[ jQuery.expando ] = {} );\n\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\touterCache = elem[ jQuery.expando ] ||\n\t\t\t\t\t\t\t\t\t( elem[ jQuery.expando ] = {} );\n\t\t\t\t\t\t\t\tcache = outerCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnodeName( node, name ) :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ jQuery.expando ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( node[ jQuery.expando ] = {} );\n\t\t\t\t\t\t\t\t\t\t\touterCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\tPSEUDO: function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// https://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar fn = jQuery.expr.pseudos[ pseudo ] ||\n\t\t\t\tjQuery.expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\tselectorError( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as jQuery does\n\t\t\tif ( fn[ jQuery.expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\n\t\t// Potentially complex pseudos\n\t\tnot: markFunction( function( selector ) {\n\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrimCSS, \"$1\" ) );\n\n\t\t\treturn matcher[ jQuery.expando ] ?\n\t\t\t\tmarkFunction( function( seed, matches, _context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\t\t\t\t\tseed[ i ] = !( matches[ i ] = elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} ) :\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tinput[ 0 ] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\n\t\t\t\t\t// Don't keep the element\n\t\t\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\t\t\tinput[ 0 ] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t} ),\n\n\t\thas: markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn find( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\tcontains: markFunction( function( text ) {\n\t\t\ttext = unescapeSelector( text );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t} ),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// https://www.w3.org/TR/selectors/#lang-pseudo\n\t\tlang: markFunction( function( lang ) {\n\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test( lang || \"\" ) ) {\n\t\t\t\tselectorError( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = unescapeSelector( lang ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( ( elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t} ),\n\n\t\t// Miscellaneous\n\t\ttarget: function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\troot: function( elem ) {\n\t\t\treturn elem === documentElement;\n\t\t},\n\n\t\tfocus: function( elem ) {\n\t\t\treturn elem === document.activeElement &&\n\t\t\t\tdocument.hasFocus() &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\tenabled: createDisabledPseudo( false ),\n\t\tdisabled: createDisabledPseudo( true ),\n\n\t\tchecked: function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\treturn ( nodeName( elem, \"input\" ) && !!elem.checked ) ||\n\t\t\t\t( nodeName( elem, \"option\" ) && !!elem.selected );\n\t\t},\n\n\t\tselected: function( elem ) {\n\n\t\t\t// Support: IE <=11+\n\t\t\t// Accessing the selectedIndex property\n\t\t\t// forces the browser to treat the default option as\n\t\t\t// selected when in an optgroup.\n\t\t\tif ( isIE && elem.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\tempty: function( elem ) {\n\n\t\t\t// https://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t// but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\tparent: function( elem ) {\n\t\t\treturn !jQuery.expr.pseudos.empty( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\theader: function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\tinput: function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\tbutton: function( elem ) {\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"button\" ||\n\t\t\t\tnodeName( elem, \"button\" );\n\t\t},\n\n\t\ttext: function( elem ) {\n\t\t\treturn nodeName( elem, \"input\" ) && elem.type === \"text\";\n\t\t},\n\n\t\t// Position-in-collection\n\t\tfirst: createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\tlast: createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\teq: createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\teven: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\todd: createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tlt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i;\n\n\t\t\tif ( argument < 0 ) {\n\t\t\t\ti = argument + length;\n\t\t\t} else if ( argument > length ) {\n\t\t\t\ti = length;\n\t\t\t} else {\n\t\t\t\ti = argument;\n\t\t\t}\n\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\tgt: createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} )\n\t}\n};\n\njQuery.expr.pseudos.nth = jQuery.expr.pseudos.eq;\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tjQuery.expr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tjQuery.expr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = jQuery.expr.pseudos;\njQuery.expr.setFilters = new setFilters();\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ jQuery.expando ] || ( elem[ jQuery.expando ] = {} );\n\n\t\t\t\t\t\tif ( skip && nodeName( elem, skip ) ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = outerCache[ key ] ) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn ( newCache[ 2 ] = oldCache[ 2 ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\touterCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[ i ]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[ 0 ];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tfind( selector, contexts[ i ], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ jQuery.expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ jQuery.expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction( function( seed, results, context, xml ) {\n\t\tvar temp, i, elem, matcherOut,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed ||\n\t\t\t\tmultipleContexts( selector || \"*\",\n\t\t\t\t\tcontext.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems;\n\n\t\tif ( matcher ) {\n\n\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter\n\t\t\t// or preexisting results,\n\t\t\tmatcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t[] :\n\n\t\t\t\t// ...otherwise use results directly\n\t\t\t\tresults;\n\n\t\t\t// Find primary matches\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t} else {\n\t\t\tmatcherOut = matcherIn;\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( ( elem = temp[ i ] ) ) {\n\t\t\t\t\tmatcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) ) {\n\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( ( matcherIn[ i ] = elem ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, ( matcherOut = [] ), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) &&\n\t\t\t\t\t\t( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {\n\n\t\t\t\t\t\tseed[ temp ] = !( results[ temp ] = elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t} );\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = jQuery.expr.relative[ tokens[ 0 ].type ],\n\t\timplicitRelative = leadingRelative || jQuery.expr.relative[ \" \" ],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf.call( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\n\t\t\t// Support: IE 11+\n\t\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tvar ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (\n\t\t\t\t( checkContext = context ).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\n\t\t\t// Avoid hanging onto element\n\t\t\t// (see https://github.com/jquery/sizzle/issues/299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( matcher = jQuery.expr.relative[ tokens[ i ].type ] ) ) {\n\t\t\tmatchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\n\t\t} else {\n\t\t\tmatcher = jQuery.expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ jQuery.expando ] ) {\n\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( jQuery.expr.relative[ tokens[ j ].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 )\n\t\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrimCSS, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && jQuery.expr.find.TAG( \"*\", outermost ),\n\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 );\n\n\t\t\tif ( outermost ) {\n\n\t\t\t\t// Support: IE 11+\n\t\t\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\toutermostContext = context == document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\tfor ( ; ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\n\t\t\t\t\t// Support: IE 11+\n\t\t\t\t\t// IE sometimes throws a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( !context && elem.ownerDocument != document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( ( matcher = elementMatchers[ j++ ] ) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml ) ) {\n\t\t\t\t\t\t\tpush.call( results, elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( ( elem = !matcher && elem ) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( ( matcher = setMatchers[ j++ ] ) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !( unmatched[ i ] || setMatched[ i ] ) ) {\n\t\t\t\t\t\t\t\tsetMatched[ i ] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tjQuery.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\nfunction compile( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[ i ] );\n\t\t\tif ( cached[ jQuery.expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n}\n\n/**\n * A low-level selection function that works with jQuery's compiled\n * selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n * selector function built with jQuery selector compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nfunction select( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( ( selector = compiled.selector || selector ) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[ 0 ] = match[ 0 ].slice( 0 );\n\t\tif ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\n\t\t\t\tcontext.nodeType === 9 && documentIsHTML &&\n\t\t\t\tjQuery.expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( jQuery.expr.find.ID(\n\t\t\t\tunescapeSelector( token.matches[ 0 ] ),\n\t\t\t\tcontext\n\t\t\t) || [] )[ 0 ];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[ i ];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( jQuery.expr.relative[ ( type = token.type ) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( ( find = jQuery.expr.find[ type ] ) ) {\n\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( ( seed = find(\n\t\t\t\t\tunescapeSelector( token.matches[ 0 ] ),\n\t\t\t\t\trsibling.test( tokens[ 0 ].type ) &&\n\t\t\t\t\t\ttestContext( context.parentNode ) || context\n\t\t\t\t) ) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n}\n\n// Initialize against the default document\nsetDocument();\n\njQuery.find = find;\n\n// These have always been private, but they used to be documented as part of\n// Sizzle so let's maintain them for now for backwards compatibility purposes.\nfind.compile = compile;\nfind.select = select;\nfind.setDocument = setDocument;\nfind.tokenize = tokenize;\n\nfunction dir( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n}\n\nfunction siblings( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n}\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\n// rsingleTag matches a string consisting of a single HTML element with no attributes\n// and captures the element's name\nvar rsingleTag = /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i;\n\nfunction isObviousHtml( input ) {\n\treturn input[ 0 ] === \"<\" &&\n\t\tinput[ input.length - 1 ] === \">\" &&\n\t\tinput.length >= 3;\n}\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( typeof qualifier === \"function\" ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\t}\n\n\t// Single element\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\t}\n\n\t// Arraylike of elements (jQuery, arguments, Array)\n\tif ( typeof qualifier !== \"string\" ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t\t} );\n\t}\n\n\t// Filtered directly for both simple and complex selectors\n\treturn jQuery.filter( qualifier, elements, not );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\tif ( elems.length === 1 && elem.nodeType === 1 ) {\n\t\treturn jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];\n\t}\n\n\treturn jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\treturn elem.nodeType === 1;\n\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i, ret,\n\t\t\tlen = this.length,\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tret = this.pushStack( [] );\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\treturn len > 1 ? jQuery.uniqueSort( ret ) : ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n// Initialize a jQuery object\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over to avoid XSS via location.hash (trac-9521)\n\t// Strict HTML recognition (trac-11290: must start with <)\n\t// Shortcut simple #id case for speed\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n\n\tinit = jQuery.fn.init = function( selector, context ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\tif ( selector.nodeType ) {\n\t\t\tthis[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( typeof selector === \"function\" ) {\n\t\t\treturn rootjQuery.ready !== undefined ?\n\t\t\t\trootjQuery.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\n\t\t} else {\n\n\t\t\t// Handle obvious HTML strings\n\t\t\tmatch = selector + \"\";\n\t\t\tif ( isObviousHtml( match ) ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip\n\t\t\t\t// the regex check. This also handles browser-supported HTML wrappers\n\t\t\t\t// like TrustedHTML.\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t// Handle HTML strings or selectors\n\t\t\t} else if ( typeof selector === \"string\" ) {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t} else {\n\t\t\t\treturn jQuery.makeArray( selector, this );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\t// Note: match[1] may be a string or a TrustedHTML wrapper\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document$1,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( typeof this[ match ] === \"function\" ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document$1.getElementById( match[ 2 ] );\n\n\t\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr) & $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || rootjQuery ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\t\t}\n\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document$1 );\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\ttargets = typeof selectors !== \"string\" && jQuery( selectors );\n\n\t\t// Positional selectors never match, since there's no _selection_ context\n\t\tif ( !rneedsContext.test( selectors ) ) {\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t\t// Always skip document fragments\n\t\t\t\t\tif ( cur.nodeType < 11 && ( targets ?\n\t\t\t\t\t\ttargets.index( cur ) > -1 :\n\n\t\t\t\t\t\t// Don't pass non-elements to jQuery#find\n\t\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, _i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\tif ( elem.contentDocument != null &&\n\n\t\t\t// Support: IE 11+\n\t\t\t// elements with no `data` attribute has an object\n\t\t\t// `contentDocument` with a `null` prototype.\n\t\t\tgetProto( elem.contentDocument ) ) {\n\n\t\t\treturn elem.contentDocument;\n\t\t}\n\n\t\t// Support: IE 9 - 11+\n\t\t// Treat the template element as a regular one in browsers that\n\t\t// don't support it.\n\t\tif ( nodeName( elem, \"template\" ) ) {\n\t\t\telem = elem.content || elem;\n\t\t}\n\n\t\treturn jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = locked || options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( typeof arg === \"function\" ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && toType( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory && !firing ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\nfunction Identity( v ) {\n\treturn v;\n}\nfunction Thrower( ex ) {\n\tthrow ex;\n}\n\nfunction adoptValue( value, resolve, reject, noValue ) {\n\tvar method;\n\n\ttry {\n\n\t\t// Check for promise aspect first to privilege synchronous behavior\n\t\tif ( value && typeof( method = value.promise ) === \"function\" ) {\n\t\t\tmethod.call( value ).done( resolve ).fail( reject );\n\n\t\t// Other thenables\n\t\t} else if ( value && typeof( method = value.then ) === \"function\" ) {\n\t\t\tmethod.call( value, resolve, reject );\n\n\t\t// Other non-thenables\n\t\t} else {\n\n\t\t\t// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n\t\t\t// * false: [ value ].slice( 0 ) => resolve( value )\n\t\t\t// * true: [ value ].slice( 1 ) => resolve()\n\t\t\tresolve.apply( undefined, [ value ].slice( noValue ) );\n\t\t}\n\n\t// For Promises/A+, convert exceptions into rejections\n\t// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n\t// Deferred#then to conditionally suppress rejection.\n\t} catch ( value ) {\n\t\treject( value );\n\t}\n}\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, callbacks,\n\t\t\t\t// ... .then handlers, argument index, [final state]\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"memory\" ), 2 ],\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 0, \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ),\n\t\t\t\t\tjQuery.Callbacks( \"once memory\" ), 1, \"rejected\" ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\tcatch: function( fn ) {\n\t\t\t\t\treturn promise.then( null, fn );\n\t\t\t\t},\n\n\t\t\t\t// Keep pipe for back-compat\n\t\t\t\tpipe: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( _i, tuple ) {\n\n\t\t\t\t\t\t\t// Map tuples (progress, done, fail) to arguments (done, fail, progress)\n\t\t\t\t\t\t\tvar fn = typeof fns[ tuple[ 4 ] ] === \"function\" &&\n\t\t\t\t\t\t\t\tfns[ tuple[ 4 ] ];\n\n\t\t\t\t\t\t\t// deferred.progress(function() { bind to newDefer or newDefer.notify })\n\t\t\t\t\t\t\t// deferred.done(function() { bind to newDefer or newDefer.resolve })\n\t\t\t\t\t\t\t// deferred.fail(function() { bind to newDefer or newDefer.reject })\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && typeof returned.promise === \"function\" ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\t\t\t\tthen: function( onFulfilled, onRejected, onProgress ) {\n\t\t\t\t\tvar maxDepth = 0;\n\t\t\t\t\tfunction resolve( depth, deferred, handler, special ) {\n\t\t\t\t\t\treturn function() {\n\t\t\t\t\t\t\tvar that = this,\n\t\t\t\t\t\t\t\targs = arguments,\n\t\t\t\t\t\t\t\tmightThrow = function() {\n\t\t\t\t\t\t\t\t\tvar returned, then;\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.3\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-59\n\t\t\t\t\t\t\t\t\t// Ignore double-resolution attempts\n\t\t\t\t\t\t\t\t\tif ( depth < maxDepth ) {\n\t\t\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\treturned = handler.apply( that, args );\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.1\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-48\n\t\t\t\t\t\t\t\t\tif ( returned === deferred.promise() ) {\n\t\t\t\t\t\t\t\t\t\tthrow new TypeError( \"Thenable self-resolution\" );\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Support: Promises/A+ sections 2.3.3.1, 3.5\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-54\n\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-75\n\t\t\t\t\t\t\t\t\t// Retrieve `then` only once\n\t\t\t\t\t\t\t\t\tthen = returned &&\n\n\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.4\n\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-64\n\t\t\t\t\t\t\t\t\t\t// Only check objects and functions for thenability\n\t\t\t\t\t\t\t\t\t\t( typeof returned === \"object\" ||\n\t\t\t\t\t\t\t\t\t\t\ttypeof returned === \"function\" ) &&\n\t\t\t\t\t\t\t\t\t\treturned.then;\n\n\t\t\t\t\t\t\t\t\t// Handle a returned thenable\n\t\t\t\t\t\t\t\t\tif ( typeof then === \"function\" ) {\n\n\t\t\t\t\t\t\t\t\t\t// Special processors (notify) just wait for resolution\n\t\t\t\t\t\t\t\t\t\tif ( special ) {\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special )\n\t\t\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\t\t// Normal processors (resolve) also hook into progress\n\t\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t\t// ...and disregard older resolution values\n\t\t\t\t\t\t\t\t\t\t\tmaxDepth++;\n\n\t\t\t\t\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\t\t\t\t\treturned,\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Thrower, special ),\n\t\t\t\t\t\t\t\t\t\t\t\tresolve( maxDepth, deferred, Identity,\n\t\t\t\t\t\t\t\t\t\t\t\t\tdeferred.notifyWith )\n\t\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t// Handle all other returned values\n\t\t\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\tif ( handler !== Identity ) {\n\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\targs = [ returned ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t// Process the value(s)\n\t\t\t\t\t\t\t\t\t\t// Default process is resolve\n\t\t\t\t\t\t\t\t\t\t( special || deferred.resolveWith )( that, args );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t},\n\n\t\t\t\t\t\t\t\t// Only normal processors (resolve) catch and reject exceptions\n\t\t\t\t\t\t\t\tprocess = special ?\n\t\t\t\t\t\t\t\t\tmightThrow :\n\t\t\t\t\t\t\t\t\tfunction() {\n\t\t\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\t\t\tmightThrow();\n\t\t\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t\t\tif ( jQuery.Deferred.exceptionHook ) {\n\t\t\t\t\t\t\t\t\t\t\t\tjQuery.Deferred.exceptionHook( e,\n\t\t\t\t\t\t\t\t\t\t\t\t\tprocess.error );\n\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.4.1\n\t\t\t\t\t\t\t\t\t\t\t// https://promisesaplus.com/#point-61\n\t\t\t\t\t\t\t\t\t\t\t// Ignore post-resolution exceptions\n\t\t\t\t\t\t\t\t\t\t\tif ( depth + 1 >= maxDepth ) {\n\n\t\t\t\t\t\t\t\t\t\t\t\t// Only substitute handlers pass on context\n\t\t\t\t\t\t\t\t\t\t\t\t// and multiple values (non-spec behavior)\n\t\t\t\t\t\t\t\t\t\t\t\tif ( handler !== Thrower ) {\n\t\t\t\t\t\t\t\t\t\t\t\t\tthat = undefined;\n\t\t\t\t\t\t\t\t\t\t\t\t\targs = [ e ];\n\t\t\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\t\t\tdeferred.rejectWith( that, args );\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// Support: Promises/A+ section 2.3.3.3.1\n\t\t\t\t\t\t\t// https://promisesaplus.com/#point-57\n\t\t\t\t\t\t\t// Re-resolve promises immediately to dodge false rejection from\n\t\t\t\t\t\t\t// subsequent errors\n\t\t\t\t\t\t\tif ( depth ) {\n\t\t\t\t\t\t\t\tprocess();\n\t\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t\t// Call an optional hook to record the error, in case of exception\n\t\t\t\t\t\t\t\t// since it's otherwise lost when execution goes async\n\t\t\t\t\t\t\t\tif ( jQuery.Deferred.getErrorHook ) {\n\t\t\t\t\t\t\t\t\tprocess.error = jQuery.Deferred.getErrorHook();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\twindow.setTimeout( process );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\n\t\t\t\t\t\t// progress_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 0 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\ttypeof onProgress === \"function\" ?\n\t\t\t\t\t\t\t\t\tonProgress :\n\t\t\t\t\t\t\t\t\tIdentity,\n\t\t\t\t\t\t\t\tnewDefer.notifyWith\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// fulfilled_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 1 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\ttypeof onFulfilled === \"function\" ?\n\t\t\t\t\t\t\t\t\tonFulfilled :\n\t\t\t\t\t\t\t\t\tIdentity\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\n\t\t\t\t\t\t// rejected_handlers.add( ... )\n\t\t\t\t\t\ttuples[ 2 ][ 3 ].add(\n\t\t\t\t\t\t\tresolve(\n\t\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t\tnewDefer,\n\t\t\t\t\t\t\t\ttypeof onRejected === \"function\" ?\n\t\t\t\t\t\t\t\t\tonRejected :\n\t\t\t\t\t\t\t\t\tThrower\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t);\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 5 ];\n\n\t\t\t// promise.progress = list.add\n\t\t\t// promise.done = list.add\n\t\t\t// promise.fail = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add(\n\t\t\t\t\tfunction() {\n\n\t\t\t\t\t\t// state = \"resolved\" (i.e., fulfilled)\n\t\t\t\t\t\t// state = \"rejected\"\n\t\t\t\t\t\tstate = stateString;\n\t\t\t\t\t},\n\n\t\t\t\t\t// rejected_callbacks.disable\n\t\t\t\t\t// fulfilled_callbacks.disable\n\t\t\t\t\ttuples[ 3 - i ][ 2 ].disable,\n\n\t\t\t\t\t// rejected_handlers.disable\n\t\t\t\t\t// fulfilled_handlers.disable\n\t\t\t\t\ttuples[ 3 - i ][ 3 ].disable,\n\n\t\t\t\t\t// progress_callbacks.lock\n\t\t\t\t\ttuples[ 0 ][ 2 ].lock,\n\n\t\t\t\t\t// progress_handlers.lock\n\t\t\t\t\ttuples[ 0 ][ 3 ].lock\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// progress_handlers.fire\n\t\t\t// fulfilled_handlers.fire\n\t\t\t// rejected_handlers.fire\n\t\t\tlist.add( tuple[ 3 ].fire );\n\n\t\t\t// deferred.notify = function() { deferred.notifyWith(...) }\n\t\t\t// deferred.resolve = function() { deferred.resolveWith(...) }\n\t\t\t// deferred.reject = function() { deferred.rejectWith(...) }\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? undefined : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\n\t\t\t// deferred.notifyWith = list.fireWith\n\t\t\t// deferred.resolveWith = list.fireWith\n\t\t\t// deferred.rejectWith = list.fireWith\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( singleValue ) {\n\t\tvar\n\n\t\t\t// count of uncompleted subordinates\n\t\t\tremaining = arguments.length,\n\n\t\t\t// count of unprocessed arguments\n\t\t\ti = remaining,\n\n\t\t\t// subordinate fulfillment data\n\t\t\tresolveContexts = Array( i ),\n\t\t\tresolveValues = slice.call( arguments ),\n\n\t\t\t// the primary Deferred\n\t\t\tprimary = jQuery.Deferred(),\n\n\t\t\t// subordinate callback factory\n\t\t\tupdateFunc = function( i ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tresolveContexts[ i ] = this;\n\t\t\t\t\tresolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( !( --remaining ) ) {\n\t\t\t\t\t\tprimary.resolveWith( resolveContexts, resolveValues );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t// Single- and empty arguments are adopted like Promise.resolve\n\t\tif ( remaining <= 1 ) {\n\t\t\tadoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,\n\t\t\t\t!remaining );\n\n\t\t\t// Use .then() to unwrap secondary thenables (cf. gh-3000)\n\t\t\tif ( primary.state() === \"pending\" ||\n\t\t\t\ttypeof( resolveValues[ i ] && resolveValues[ i ].then ) === \"function\" ) {\n\n\t\t\t\treturn primary.then();\n\t\t\t}\n\t\t}\n\n\t\t// Multiple arguments are aggregated like Promise.all array elements\n\t\twhile ( i-- ) {\n\t\t\tadoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );\n\t\t}\n\n\t\treturn primary.promise();\n\t}\n} );\n\n// These usually indicate a programmer mistake during development,\n// warn about them ASAP rather than swallowing them by default.\nvar rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error\n// captured before the async barrier to get the original error cause\n// which may otherwise be hidden.\njQuery.Deferred.exceptionHook = function( error, asyncError ) {\n\n\tif ( error && rerrorNames.test( error.name ) ) {\n\t\twindow.console.warn(\n\t\t\t\"jQuery.Deferred exception\",\n\t\t\terror,\n\t\t\tasyncError\n\t\t);\n\t}\n};\n\njQuery.readyException = function( error ) {\n\twindow.setTimeout( function() {\n\t\tthrow error;\n\t} );\n};\n\n// The deferred used on DOM ready\nvar readyList = jQuery.Deferred();\n\njQuery.fn.ready = function( fn ) {\n\n\treadyList\n\t\t.then( fn )\n\n\t\t// Wrap jQuery.readyException in a function so that the lookup\n\t\t// happens at the time of error handling instead of callback\n\t\t// registration.\n\t\t.catch( function( error ) {\n\t\t\tjQuery.readyException( error );\n\t\t} );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See trac-6781\n\treadyWait: 1,\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document$1, [ jQuery ] );\n\t}\n} );\n\njQuery.ready.then = readyList.then;\n\n// The ready event handler and self cleanup method\nfunction completed() {\n\tdocument$1.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\n// Catch cases where $(document).ready() is called\n// after the browser event has already occurred.\nif ( document$1.readyState !== \"loading\" ) {\n\n\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\twindow.setTimeout( jQuery.ready );\n\n} else {\n\n\t// Use the handy event callback\n\tdocument$1.addEventListener( \"DOMContentLoaded\", completed );\n\n\t// A fallback to window.onload, that will always work\n\twindow.addEventListener( \"load\", completed );\n}\n\n// Matches dashed string for camelizing\nvar rdashAlpha = /-([a-z])/g;\n\n// Used by camelCase as callback to replace()\nfunction fcamelCase( _all, letter ) {\n\treturn letter.toUpperCase();\n}\n\n// Convert dashed to camelCase\nfunction camelCase( string ) {\n\treturn string.replace( rdashAlpha, fcamelCase );\n}\n\n/**\n * Determines whether an object can have data\n */\nfunction acceptData( owner ) {\n\n\t// Accepts only:\n\t// - Node\n\t// - Node.ELEMENT_NODE\n\t// - Node.DOCUMENT_NODE\n\t// - Object\n\t// - Any\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n}\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tcache: function( owner ) {\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = Object.create( null );\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see trac-8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\t// Always use camelCase key (gh-2257)\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ camelCase( data ) ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ camelCase( prop ) ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn value;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\n\t\t\t// Always use camelCase key (gh-2257)\n\t\t\towner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];\n\t},\n\taccess: function( owner, key, value ) {\n\n\t\t// In cases where either:\n\t\t//\n\t\t// 1. No key was specified\n\t\t// 2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t// 1. The entire cache object\n\t\t// 2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\treturn this.get( owner, key );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t// 1. An object of properties\n\t\t// 2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key !== undefined ) {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( Array.isArray( key ) ) {\n\n\t\t\t\t// If key is an array of keys...\n\t\t\t\t// We always set camelCase keys, so remove that.\n\t\t\t\tkey = key.map( camelCase );\n\t\t\t} else {\n\t\t\t\tkey = camelCase( key );\n\n\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\tkey = key in cache ?\n\t\t\t\t\t[ key ] :\n\t\t\t\t\t( key.match( rnothtmlwhite ) || [] );\n\t\t\t}\n\n\t\t\ti = key.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ key[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\n\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction getData( data ) {\n\tif ( data === \"true\" ) {\n\t\treturn true;\n\t}\n\n\tif ( data === \"false\" ) {\n\t\treturn false;\n\t}\n\n\tif ( data === \"null\" ) {\n\t\treturn null;\n\t}\n\n\t// Only convert to a number if it doesn't change the string\n\tif ( data === +data + \"\" ) {\n\t\treturn +data;\n\t}\n\n\tif ( rbrace.test( data ) ) {\n\t\treturn JSON.parse( data );\n\t}\n\n\treturn data;\n}\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = getData( data );\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE 11+\n\t\t\t\t\t\t// The attrs elements can be null (trac-14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// The key will always be camelCased in Data\n\t\t\t\tdata = dataUser.get( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, key );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tthis.each( function() {\n\n\t\t\t\t// We always store the camelCased key\n\t\t\t\tdataUser.set( this, key, value );\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || Array.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.set( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.set( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\n\nvar pnum = /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/.source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\n// isHiddenWithinTree reports if an element has a non-\"none\" display style (inline and/or\n// through the CSS cascade), which is useful in deciding whether or not to make it visible.\n// It differs from the :hidden selector (jQuery.expr.pseudos.hidden) in two important ways:\n// * A hidden ancestor does not force an element to be classified as hidden.\n// * Being disconnected from the document does not force an element to be classified as hidden.\n// These differences improve the behavior of .toggle() et al. when applied to elements that are\n// detached or contained within hidden ancestors (gh-2404, gh-2863).\nfunction isHiddenWithinTree( elem, el ) {\n\n\t// isHiddenWithinTree might be called from jQuery#filter function;\n\t// in that case, element will be second argument\n\telem = el || elem;\n\n\t// Inline style trumps all\n\treturn elem.style.display === \"none\" ||\n\t\telem.style.display === \"\" &&\n\t\tjQuery.css( elem, \"display\" ) === \"none\";\n}\n\nvar ralphaStart = /^[a-z]/,\n\n\t// The regex visualized:\n\t//\n\t// /----------\\\n\t// | | /-------\\\n\t// | / Top \\ | | |\n\t// /--- Border ---+-| Right |-+---+- Width -+---\\\n\t// | | Bottom | |\n\t// | \\ Left / |\n\t// | |\n\t// | /----------\\ |\n\t// | /-------------\\ | | |- END\n\t// | | | | / Top \\ | |\n\t// | | / Margin \\ | | | Right | | |\n\t// |---------+-| |-+---+-| Bottom |-+----|\n\t// | \\ Padding / \\ Left / |\n\t// BEGIN -| |\n\t// | /---------\\ |\n\t// | | | |\n\t// | | / Min \\ | / Width \\ |\n\t// \\--------------+-| |-+---| |---/\n\t// \\ Max / \\ Height /\n\trautoPx = /^(?:Border(?:Top|Right|Bottom|Left)?(?:Width|)|(?:Margin|Padding)?(?:Top|Right|Bottom|Left)?|(?:Min|Max)?(?:Width|Height))$/;\n\nfunction isAutoPx( prop ) {\n\n\t// The first test is used to ensure that:\n\t// 1. The prop starts with a lowercase letter (as we uppercase it for the second regex).\n\t// 2. The prop is not empty.\n\treturn ralphaStart.test( prop ) &&\n\t\trautoPx.test( prop[ 0 ].toUpperCase() + prop.slice( 1 ) );\n}\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted, scale,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() {\n\t\t\t\treturn tween.cur();\n\t\t\t} :\n\t\t\tfunction() {\n\t\t\t\treturn jQuery.css( elem, prop, \"\" );\n\t\t\t},\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( isAutoPx( prop ) ? \"px\" : \"\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = elem.nodeType &&\n\t\t\t( !isAutoPx( prop ) || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Support: Firefox <=54 - 66+\n\t\t// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n\t\tinitial = initial / 2;\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\twhile ( maxIterations-- ) {\n\n\t\t\t// Evaluate and update our best guess (doubling guesses that zero out).\n\t\t\t// Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\t\t\tif ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {\n\t\t\t\tmaxIterations = 0;\n\t\t\t}\n\t\t\tinitialInUnit = initialInUnit / scale;\n\n\t\t}\n\n\t\tinitialInUnit = initialInUnit * 2;\n\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\n\n// Matches dashed string for camelizing\nvar rmsPrefix = /^-ms-/;\n\n// Convert dashed to camelCase, handle vendor prefixes.\n// Used by the css & effects modules.\n// Support: IE <=9 - 11+\n// Microsoft forgot to hump their vendor prefix (trac-9572)\nfunction cssCamelCase( string ) {\n\treturn camelCase( string.replace( rmsPrefix, \"ms-\" ) );\n}\n\nvar defaultDisplayMap = {};\n\nfunction getDefaultDisplay( elem ) {\n\tvar temp,\n\t\tdoc = elem.ownerDocument,\n\t\tnodeName = elem.nodeName,\n\t\tdisplay = defaultDisplayMap[ nodeName ];\n\n\tif ( display ) {\n\t\treturn display;\n\t}\n\n\ttemp = doc.body.appendChild( doc.createElement( nodeName ) );\n\tdisplay = jQuery.css( temp, \"display\" );\n\n\ttemp.parentNode.removeChild( temp );\n\n\tif ( display === \"none\" ) {\n\t\tdisplay = \"block\";\n\t}\n\tdefaultDisplayMap[ nodeName ] = display;\n\n\treturn display;\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\t// Determine new display value for elements that need to change\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n\t\t\t// check is required in this first loop unless we have a nonempty display value (either\n\t\t\t// inline or about-to-be-restored)\n\t\t\tif ( display === \"none\" ) {\n\t\t\t\tvalues[ index ] = dataPriv.get( elem, \"display\" ) || null;\n\t\t\t\tif ( !values[ index ] ) {\n\t\t\t\t\telem.style.display = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ( elem.style.display === \"\" && isHiddenWithinTree( elem ) ) {\n\t\t\t\tvalues[ index ] = getDefaultDisplay( elem );\n\t\t\t}\n\t\t} else {\n\t\t\tif ( display !== \"none\" ) {\n\t\t\t\tvalues[ index ] = \"none\";\n\n\t\t\t\t// Remember what we're overwriting\n\t\t\t\tdataPriv.set( elem, \"display\", display );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of the elements in a second loop to avoid constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\tif ( values[ index ] != null ) {\n\t\t\telements[ index ].style.display = values[ index ];\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.fn.extend( {\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHiddenWithinTree( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\n\nvar isAttached = function( elem ) {\n\t\treturn jQuery.contains( elem.ownerDocument, elem ) ||\n\t\t\telem.getRootNode( composed ) === elem.ownerDocument;\n\t},\n\tcomposed = { composed: true };\n\n// Support: IE 9 - 11+\n// Check attachment across shadow DOM boundaries when possible (gh-3504).\n// Provide a fallback for browsers without Shadow DOM v1 support.\nif ( !documentElement$1.getRootNode ) {\n\tisAttached = function( elem ) {\n\t\treturn jQuery.contains( elem.ownerDocument, elem );\n\t};\n}\n\n// rtagName captures the name from the first start tag in a string of HTML\n// https://html.spec.whatwg.org/multipage/syntax.html#tag-open-state\n// https://html.spec.whatwg.org/multipage/syntax.html#tag-name-state\nvar rtagName = /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i;\n\nvar wrapMap = {\n\n\t// Table parts need to be wrapped with `` or they're\n\t// stripped to their contents when put in a div.\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do, so we cannot shorten\n\t// this by omitting or other required elements.\n\tthead: [ \"table\" ],\n\tcol: [ \"colgroup\", \"table\" ],\n\ttr: [ \"tbody\", \"table\" ],\n\ttd: [ \"tr\", \"tbody\", \"table\" ]\n};\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE <=9 - 11+\n\t// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)\n\tvar ret;\n\n\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\n\t\t// Use slice to snapshot the live collection from gEBTN\n\t\tret = arr.slice.call( context.getElementsByTagName( tag || \"*\" ) );\n\n\t} else if ( typeof context.querySelectorAll !== \"undefined\" ) {\n\t\tret = context.querySelectorAll( tag || \"*\" );\n\n\t} else {\n\t\tret = [];\n\t}\n\n\tif ( tag === undefined || tag && nodeName( context, tag ) ) {\n\t\treturn jQuery.merge( [ context ], ret );\n\t}\n\n\treturn ret;\n}\n\nvar rscriptType = /^$|^module$|\\/(?:java|ecma)script/i;\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, attached, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( toType( elem ) === \"object\" && ( elem.nodeType || isArrayLike( elem ) ) ) {\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || arr;\n\n\t\t\t\t// Create wrappers & descend into them.\n\t\t\t\tj = wrap.length;\n\t\t\t\twhile ( --j > -1 ) {\n\t\t\t\t\ttmp = tmp.appendChild( context.createElement( wrap[ j ] ) );\n\t\t\t\t}\n\n\t\t\t\ttmp.innerHTML = jQuery.htmlPrefilter( elem );\n\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (trac-12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tattached = isAttached( elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( attached ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tif ( ( elem.type || \"\" ).slice( 0, 5 ) === \"true/\" ) {\n\t\telem.type = elem.type.slice( 5 );\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = flat( args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tvalueIsFunction = typeof value === \"function\";\n\n\tif ( valueIsFunction ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (trac-8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Re-enable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.get( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src && ( node.type || \"\" ).toLowerCase() !== \"module\" ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl && !node.noModule ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src, {\n\t\t\t\t\t\t\t\t\tnonce: node.nonce,\n\t\t\t\t\t\t\t\t\tcrossOrigin: node.crossOrigin\n\t\t\t\t\t\t\t\t}, doc );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tDOMEval( node.textContent, node, doc );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nvar rcheckableType = /^(?:checkbox|radio)$/i;\n\nvar rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Only attach events to objects that accept data\n\t\tif ( !acceptData( elem ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Ensure that invalid selectors throw exceptions at attach time\n\t\t// Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\t\tif ( selector ) {\n\t\t\tjQuery.find.matchesSelector( documentElement$1, selector );\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = Object.create( null );\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnothtmlwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( nativeEvent ) {\n\n\t\tvar i, j, ret, matched, handleObj, handlerQueue,\n\t\t\targs = new Array( arguments.length ),\n\n\t\t\t// Make a writable jQuery.Event from the native event object\n\t\t\tevent = jQuery.event.fix( nativeEvent ),\n\n\t\t\thandlers = (\n\t\t\t\tdataPriv.get( this, \"events\" ) || Object.create( null )\n\t\t\t)[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\n\t\tfor ( i = 1; i < arguments.length; i++ ) {\n\t\t\targs[ i ] = arguments[ i ];\n\t\t}\n\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// If the event is namespaced, then each handler is only invoked if it is\n\t\t\t\t// specially universal or its namespaces are a superset of the event's.\n\t\t\t\tif ( !event.rnamespace || handleObj.namespace === false ||\n\t\t\t\t\tevent.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, handleObj, sel, matchedHandlers, matchedSelectors,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Find delegate handlers\n\t\tif ( delegateCount &&\n\n\t\t\t// Support: Firefox <=42 - 66+\n\t\t\t// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n\t\t\t// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n\t\t\t// Support: IE 11+\n\t\t\t// ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n\t\t\t!( event.type === \"click\" && event.button >= 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (trac-13208)\n\t\t\t\t// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)\n\t\t\t\tif ( cur.nodeType === 1 && !( event.type === \"click\" && cur.disabled === true ) ) {\n\t\t\t\t\tmatchedHandlers = [];\n\t\t\t\t\tmatchedSelectors = {};\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (trac-13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatchedSelectors[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matchedSelectors[ sel ] ) {\n\t\t\t\t\t\t\tmatchedHandlers.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matchedHandlers.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matchedHandlers } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tcur = this;\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\taddProp: function( name, hook ) {\n\t\tObject.defineProperty( jQuery.Event.prototype, name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\n\t\t\tget: typeof hook === \"function\" ?\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn hook( this.originalEvent );\n\t\t\t\t\t}\n\t\t\t\t} :\n\t\t\t\tfunction() {\n\t\t\t\t\tif ( this.originalEvent ) {\n\t\t\t\t\t\treturn this.originalEvent[ name ];\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\tset: function( value ) {\n\t\t\t\tObject.defineProperty( this, name, {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\twritable: true,\n\t\t\t\t\tvalue: value\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\t},\n\n\tfix: function( originalEvent ) {\n\t\treturn originalEvent[ jQuery.expando ] ?\n\t\t\toriginalEvent :\n\t\t\tnew jQuery.Event( originalEvent );\n\t},\n\n\tspecial: jQuery.extend( Object.create( null ), {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tclick: {\n\n\t\t\t// Utilize native event to ensure correct state for checkable inputs\n\t\t\tsetup: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Claim the first handler\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\t// dataPriv.set( el, \"click\", ... )\n\t\t\t\t\tleverageNative( el, \"click\", true );\n\t\t\t\t}\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\ttrigger: function( data ) {\n\n\t\t\t\t// For mutual compressibility with _default, replace `this` access with a local var.\n\t\t\t\t// `|| data` is dead code meant only to preserve the variable through minification.\n\t\t\t\tvar el = this || data;\n\n\t\t\t\t// Force setup before triggering a click\n\t\t\t\tif ( rcheckableType.test( el.type ) &&\n\t\t\t\t\tel.click && nodeName( el, \"input\" ) ) {\n\n\t\t\t\t\tleverageNative( el, \"click\" );\n\t\t\t\t}\n\n\t\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\t\treturn true;\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, suppress native .click() on links\n\t\t\t// Also prevent it if we're currently inside a leveraged native-event stack\n\t\t\t_default: function( event ) {\n\t\t\t\tvar target = event.target;\n\t\t\t\treturn rcheckableType.test( target.type ) &&\n\t\t\t\t\ttarget.click && nodeName( target, \"input\" ) &&\n\t\t\t\t\tdataPriv.get( target, \"click\" ) ||\n\t\t\t\t\tnodeName( target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\t\t\t\tif ( event.result !== undefined ) {\n\n\t\t\t\t\t// Setting `event.originalEvent.returnValue` in modern\n\t\t\t\t\t// browsers does the same as just calling `preventDefault()`,\n\t\t\t\t\t// the browsers ignore the value anyway.\n\t\t\t\t\t// Incidentally, IE 11 is the only browser from our supported\n\t\t\t\t\t// ones which respects the value returned from a `beforeunload`\n\t\t\t\t\t// handler attached by `addEventListener`; other browsers do\n\t\t\t\t\t// so only for inline handlers, so not setting the value\n\t\t\t\t\t// directly shouldn't reduce any functionality.\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t} )\n};\n\n// Ensure the presence of an event listener that handles manually-triggered\n// synthetic events by interrupting progress until reinvoked in response to\n// *native* events that it fires directly, ensuring that state changes have\n// already occurred before other listeners are invoked.\nfunction leverageNative( el, type, isSetup ) {\n\n\t// Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add\n\tif ( !isSetup ) {\n\t\tif ( dataPriv.get( el, type ) === undefined ) {\n\t\t\tjQuery.event.add( el, type, returnTrue );\n\t\t}\n\t\treturn;\n\t}\n\n\t// Register the controller as a special universal handler for all event namespaces\n\tdataPriv.set( el, type, false );\n\tjQuery.event.add( el, type, {\n\t\tnamespace: false,\n\t\thandler: function( event ) {\n\t\t\tvar result,\n\t\t\t\tsaved = dataPriv.get( this, type );\n\n\t\t\t// This controller function is invoked under multiple circumstances,\n\t\t\t// differentiated by the stored value in `saved`:\n\t\t\t// 1. For an outer synthetic `.trigger()`ed event (detected by\n\t\t\t// `event.isTrigger & 1` and non-array `saved`), it records arguments\n\t\t\t// as an array and fires an [inner] native event to prompt state\n\t\t\t// changes that should be observed by registered listeners (such as\n\t\t\t// checkbox toggling and focus updating), then clears the stored value.\n\t\t\t// 2. For an [inner] native event (detected by `saved` being\n\t\t\t// an array), it triggers an inner synthetic event, records the\n\t\t\t// result, and preempts propagation to further jQuery listeners.\n\t\t\t// 3. For an inner synthetic event (detected by `event.isTrigger & 1` and\n\t\t\t// array `saved`), it prevents double-propagation of surrogate events\n\t\t\t// but otherwise allows everything to proceed (particularly including\n\t\t\t// further listeners).\n\t\t\t// Possible `saved` data shapes: `[...], `{ value }`, `false`.\n\t\t\tif ( ( event.isTrigger & 1 ) && this[ type ] ) {\n\n\t\t\t\t// Interrupt processing of the outer synthetic .trigger()ed event\n\t\t\t\tif ( !saved.length ) {\n\n\t\t\t\t\t// Store arguments for use when handling the inner native event\n\t\t\t\t\t// There will always be at least one argument (an event object),\n\t\t\t\t\t// so this array will not be confused with a leftover capture object.\n\t\t\t\t\tsaved = slice.call( arguments );\n\t\t\t\t\tdataPriv.set( this, type, saved );\n\n\t\t\t\t\t// Trigger the native event and capture its result\n\t\t\t\t\tthis[ type ]();\n\t\t\t\t\tresult = dataPriv.get( this, type );\n\t\t\t\t\tdataPriv.set( this, type, false );\n\n\t\t\t\t\tif ( saved !== result ) {\n\n\t\t\t\t\t\t// Cancel the outer synthetic event\n\t\t\t\t\t\tevent.stopImmediatePropagation();\n\t\t\t\t\t\tevent.preventDefault();\n\n\t\t\t\t\t\t// Support: Chrome 86+\n\t\t\t\t\t\t// In Chrome, if an element having a focusout handler is\n\t\t\t\t\t\t// blurred by clicking outside of it, it invokes the handler\n\t\t\t\t\t\t// synchronously. If that handler calls `.remove()` on\n\t\t\t\t\t\t// the element, the data is cleared, leaving `result`\n\t\t\t\t\t\t// undefined. We need to guard against this.\n\t\t\t\t\t\treturn result && result.value;\n\t\t\t\t\t}\n\n\t\t\t\t// If this is an inner synthetic event for an event with a bubbling\n\t\t\t\t// surrogate (focus or blur), assume that the surrogate already\n\t\t\t\t// propagated from triggering the native event and prevent that\n\t\t\t\t// from happening again here.\n\t\t\t\t} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {\n\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t}\n\n\t\t\t// If this is a native event triggered above, everything is now in order.\n\t\t\t// Fire an inner synthetic event with the original arguments.\n\t\t\t} else if ( saved.length ) {\n\n\t\t\t\t// ...and capture the result\n\t\t\t\tdataPriv.set( this, type, {\n\t\t\t\t\tvalue: jQuery.event.trigger(\n\t\t\t\t\t\tsaved[ 0 ],\n\t\t\t\t\t\tsaved.slice( 1 ),\n\t\t\t\t\t\tthis\n\t\t\t\t\t)\n\t\t\t\t} );\n\n\t\t\t\t// Abort handling of the native event by all jQuery handlers while allowing\n\t\t\t\t// native handlers on the same element to run. On target, this is achieved\n\t\t\t\t// by stopping immediate propagation just on the jQuery event. However,\n\t\t\t\t// the native event is re-wrapped by a jQuery one on each level of the\n\t\t\t\t// propagation so the only way to stop it for jQuery is to stop it for\n\t\t\t\t// everyone via native `stopPropagation()`. This is not a problem for\n\t\t\t\t// focus/blur which don't bubble, but it does also stop click on checkboxes\n\t\t\t\t// and radios. We accept this limitation.\n\t\t\t\tevent.stopPropagation();\n\t\t\t\tevent.isImmediatePropagationStopped = returnTrue;\n\t\t\t}\n\t\t}\n\t} );\n}\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t\t// Create target properties\n\t\tthis.target = src.target;\n\t\tthis.currentTarget = src.currentTarget;\n\t\tthis.relatedTarget = src.relatedTarget;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || Date.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Includes all common event props including KeyEvent and MouseEvent specific props\njQuery.each( {\n\taltKey: true,\n\tbubbles: true,\n\tcancelable: true,\n\tchangedTouches: true,\n\tctrlKey: true,\n\tdetail: true,\n\teventPhase: true,\n\tmetaKey: true,\n\tpageX: true,\n\tpageY: true,\n\tshiftKey: true,\n\tview: true,\n\t\"char\": true,\n\tcode: true,\n\tcharCode: true,\n\tkey: true,\n\tkeyCode: true,\n\tbutton: true,\n\tbuttons: true,\n\tclientX: true,\n\tclientY: true,\n\toffsetX: true,\n\toffsetY: true,\n\tpointerId: true,\n\tpointerType: true,\n\tscreenX: true,\n\tscreenY: true,\n\ttargetTouches: true,\n\ttoElement: true,\n\ttouches: true,\n\twhich: true\n}, jQuery.event.addProp );\n\njQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( type, delegateType ) {\n\n\t// Support: IE 11+\n\t// Attach a single focusin/focusout handler on the document while someone wants focus/blur.\n\t// This is because the former are synchronous in IE while the latter are async. In other\n\t// browsers, all those handlers are invoked synchronously.\n\tfunction focusMappedHandler( nativeEvent ) {\n\n\t\t// `eventHandle` would already wrap the event, but we need to change the `type` here.\n\t\tvar event = jQuery.event.fix( nativeEvent );\n\t\tevent.type = nativeEvent.type === \"focusin\" ? \"focus\" : \"blur\";\n\t\tevent.isSimulated = true;\n\n\t\t// focus/blur don't bubble while focusin/focusout do; simulate the former by only\n\t\t// invoking the handler at the lower level.\n\t\tif ( event.target === event.currentTarget ) {\n\n\t\t\t// The setup part calls `leverageNative`, which, in turn, calls\n\t\t\t// `jQuery.event.add`, so event handle will already have been set\n\t\t\t// by this point.\n\t\t\tdataPriv.get( this, \"handle\" )( event );\n\t\t}\n\t}\n\n\tjQuery.event.special[ type ] = {\n\n\t\t// Utilize native event if possible so blur/focus sequence is correct\n\t\tsetup: function() {\n\n\t\t\t// Claim the first handler\n\t\t\t// dataPriv.set( this, \"focus\", ... )\n\t\t\t// dataPriv.set( this, \"blur\", ... )\n\t\t\tleverageNative( this, type, true );\n\n\t\t\tif ( isIE ) {\n\t\t\t\tthis.addEventListener( delegateType, focusMappedHandler );\n\t\t\t} else {\n\n\t\t\t\t// Return false to allow normal processing in the caller\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\t\ttrigger: function() {\n\n\t\t\t// Force setup before trigger\n\t\t\tleverageNative( this, type );\n\n\t\t\t// Return non-false to allow normal event-path propagation\n\t\t\treturn true;\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tif ( isIE ) {\n\t\t\t\tthis.removeEventListener( delegateType, focusMappedHandler );\n\t\t\t} else {\n\n\t\t\t\t// Return false to indicate standard teardown should be applied\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\n\t\t// Suppress native focus or blur if we're currently inside\n\t\t// a leveraged native-event stack\n\t\t_default: function( event ) {\n\t\t\treturn dataPriv.get( event.target, type );\n\t\t},\n\n\t\tdelegateType: delegateType\n\t};\n} );\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event ) dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\nvar\n\n\t// Support: IE <=10 - 11+\n\t// In IE using regex groups here causes severe slowdowns.\n\trnoInnerhtml = / 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <=35 - 45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\t\t\tpush.apply( ret, elems );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\n\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar rcustomProp = /^--/;\n\nfunction getStyles( elem ) {\n\n\t// Support: IE <=11+ (trac-14150)\n\t// In IE popup's `window` is the opener window which makes `window.getComputedStyle( elem )`\n\t// break. Using `elem.ownerDocument.defaultView` avoids the issue.\n\tvar view = elem.ownerDocument.defaultView;\n\n\t// `document.implementation.createHTMLDocument( \"\" )` has a `null` `defaultView`\n\t// property; check `defaultView` truthiness to fallback to window in such a case.\n\tif ( !view ) {\n\t\tview = window;\n\t}\n\n\treturn view.getComputedStyle( elem );\n}\n\n// A method for quickly swapping in/out CSS properties to get correct calculations.\nfunction swap( elem, options, callback ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.call( elem );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n}\n\nfunction curCSS( elem, name, computed ) {\n\tvar ret,\n\t\tisCustomProp = rcustomProp.test( name );\n\n\tcomputed = computed || getStyles( elem );\n\n\t// getPropertyValue is needed for `.css('--customProperty')` (gh-3144)\n\tif ( computed ) {\n\n\t\t// A fallback to direct property access is needed as `computed`, being\n\t\t// the output of `getComputedStyle`, contains camelCased keys and\n\t\t// `getPropertyValue` requires kebab-case ones.\n\t\t//\n\t\t// Support: IE <=9 - 11+\n\t\t// IE only supports `\"float\"` in `getPropertyValue`; in computed styles\n\t\t// it's only available as `\"cssFloat\"`. We no longer modify properties\n\t\t// sent to `.css()` apart from camelCasing, so we need to check both.\n\t\t// Normally, this would create difference in behavior: if\n\t\t// `getPropertyValue` returns an empty string, the value returned\n\t\t// by `.css()` would be `undefined`. This is usually the case for\n\t\t// disconnected elements. However, in IE even disconnected elements\n\t\t// with no styles return `\"none\"` for `getPropertyValue( \"float\" )`\n\t\tret = computed.getPropertyValue( name ) || computed[ name ];\n\n\t\tif ( isCustomProp && ret ) {\n\n\t\t\t// Support: Firefox 105 - 135+\n\t\t\t// Spec requires trimming whitespace for custom properties (gh-4926).\n\t\t\t// Firefox only trims leading whitespace.\n\t\t\t//\n\t\t\t// Fall back to `undefined` if empty string returned.\n\t\t\t// This collapses a missing definition with property defined\n\t\t\t// and set to an empty string but there's no standard API\n\t\t\t// allowing us to differentiate them without a performance penalty\n\t\t\t// and returning `undefined` aligns with older jQuery.\n\t\t\t//\n\t\t\t// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED\n\t\t\t// as whitespace while CSS does not, but this is not a problem\n\t\t\t// because CSS preprocessing replaces them with U+000A LINE FEED\n\t\t\t// (which *is* CSS whitespace)\n\t\t\t// https://www.w3.org/TR/css-syntax-3/#input-preprocessing\n\t\t\tret = ret.replace( rtrimCSS, \"$1\" ) || undefined;\n\t\t}\n\n\t\tif ( ret === \"\" && !isAttached( elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE <=9 - 11+\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\nvar cssPrefixes = [ \"Webkit\", \"Moz\", \"ms\" ],\n\temptyStyle = document$1.createElement( \"div\" ).style;\n\n// Return a vendor-prefixed property or undefined\nfunction vendorPropName( name ) {\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\n// Return a potentially-mapped vendor prefixed property\nfunction finalPropName( name ) {\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\treturn vendorPropName( name ) || name;\n}\n\nvar reliableTrDimensionsVal, reliableColDimensionsVal,\n\ttable = document$1.createElement( \"table\" );\n\n// Executing table tests requires only one layout, so they're executed\n// at the same time to save the second computation.\nfunction computeTableStyleTests() {\n\tif (\n\n\t\t// This is a singleton, we need to execute it only once\n\t\t!table ||\n\n\t\t// Finish early in limited (non-browser) environments\n\t\t!table.style\n\t) {\n\t\treturn;\n\t}\n\n\tvar trStyle,\n\t\tcol = document$1.createElement( \"col\" ),\n\t\ttr = document$1.createElement( \"tr\" ),\n\t\ttd = document$1.createElement( \"td\" );\n\n\ttable.style.cssText = \"position:absolute;left:-11111px;\" +\n\t\t\"border-collapse:separate;border-spacing:0\";\n\ttr.style.cssText = \"box-sizing:content-box;border:1px solid;height:1px\";\n\ttd.style.cssText = \"height:9px;width:9px;padding:0\";\n\n\tcol.span = 2;\n\n\tdocumentElement$1\n\t\t.appendChild( table )\n\t\t.appendChild( col )\n\t\t.parentNode\n\t\t.appendChild( tr )\n\t\t.appendChild( td )\n\t\t.parentNode\n\t\t.appendChild( td.cloneNode( true ) );\n\n\t// Don't run until window is visible\n\tif ( table.offsetWidth === 0 ) {\n\t\tdocumentElement$1.removeChild( table );\n\t\treturn;\n\t}\n\n\ttrStyle = window.getComputedStyle( tr );\n\n\t// Support: Firefox 135+\n\t// Firefox always reports computed width as if `span` was 1.\n\t// Support: Safari 18.3+\n\t// In Safari, computed width for columns is always 0.\n\t// In both these browsers, using `offsetWidth` solves the issue.\n\t// Support: IE 11+\n\t// In IE, `` computed width is `\"auto\"` unless `width` is set\n\t// explicitly via CSS so measurements there remain incorrect. Because of\n\t// the lack of a proper workaround, we accept this limitation, treating\n\t// IE as passing the test.\n\treliableColDimensionsVal = isIE || Math.round( parseFloat(\n\t\twindow.getComputedStyle( col ).width )\n\t) === 18;\n\n\t// Support: IE 10 - 11+\n\t// IE misreports `getComputedStyle` of table rows with width/height\n\t// set in CSS while `offset*` properties report correct values.\n\t// Support: Firefox 70 - 135+\n\t// Only Firefox includes border widths\n\t// in computed dimensions for table rows. (gh-4529)\n\treliableTrDimensionsVal = Math.round( parseFloat( trStyle.height ) +\n\t\tparseFloat( trStyle.borderTopWidth ) +\n\t\tparseFloat( trStyle.borderBottomWidth ) ) === tr.offsetHeight;\n\n\tdocumentElement$1.removeChild( table );\n\n\t// Nullify the table so it wouldn't be stored in the memory;\n\t// it will also be a sign that checks were already performed.\n\ttable = null;\n}\n\njQuery.extend( support, {\n\treliableTrDimensions: function() {\n\t\tcomputeTableStyleTests();\n\t\treturn reliableTrDimensionsVal;\n\t},\n\n\treliableColDimensions: function() {\n\t\tcomputeTableStyleTests();\n\t\treturn reliableColDimensionsVal;\n\t}\n} );\n\nvar cssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t};\n\nfunction setPositiveNumber( _elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {\n\tvar i = dimension === \"width\" ? 1 : 0,\n\t\textra = 0,\n\t\tdelta = 0,\n\t\tmarginDelta = 0;\n\n\t// Adjustment may not be necessary\n\tif ( box === ( isBorderBox ? \"border\" : \"content\" ) ) {\n\t\treturn 0;\n\t}\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin\n\t\t// Count margin delta separately to only add it after scroll gutter adjustment.\n\t\t// This is needed to make negative margins work with `outerHeight( true )` (gh-3982).\n\t\tif ( box === \"margin\" ) {\n\t\t\tmarginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\t// If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\t\tif ( !isBorderBox ) {\n\n\t\t\t// Add padding\n\t\t\tdelta += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// For \"border\" or \"margin\", add border\n\t\t\tif ( box !== \"padding\" ) {\n\t\t\t\tdelta += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\n\t\t\t// But still keep track of it otherwise\n\t\t\t} else {\n\t\t\t\textra += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\n\t\t// If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n\t\t// \"padding\" or \"margin\"\n\t\t} else {\n\n\t\t\t// For \"content\", subtract padding\n\t\t\tif ( box === \"content\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// For \"content\" or \"padding\", subtract border\n\t\t\tif ( box !== \"margin\" ) {\n\t\t\t\tdelta -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\t// Account for positive content-box scroll gutter when requested by providing computedVal\n\tif ( !isBorderBox && computedVal >= 0 ) {\n\n\t\t// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n\t\t// Assuming integer scroll gutter, subtract the rest and round down\n\t\tdelta += Math.max( 0, Math.ceil(\n\t\t\telem[ \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -\n\t\t\tcomputedVal -\n\t\t\tdelta -\n\t\t\textra -\n\t\t\t0.5\n\n\t\t// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n\t\t// Use an explicit zero to avoid NaN (gh-3964)\n\t\t) ) || 0;\n\t}\n\n\treturn delta + marginDelta;\n}\n\nfunction getWidthOrHeight( elem, dimension, extra ) {\n\n\t// Start with computed style\n\tvar styles = getStyles( elem ),\n\n\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n\t\t// Fake content-box until we know it's needed to know the true value.\n\t\tboxSizingNeeded = isIE || extra,\n\t\tisBorderBox = boxSizingNeeded &&\n\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\tvalueIsBorderBox = isBorderBox,\n\n\t\tval = curCSS( elem, dimension, styles ),\n\t\toffsetProp = \"offset\" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );\n\n\t// Return a confounding non-pixel value or feign ignorance, as appropriate.\n\tif ( rnumnonpx.test( val ) ) {\n\t\tif ( !extra ) {\n\t\t\treturn val;\n\t\t}\n\t\tval = \"auto\";\n\t}\n\n\n\tif (\n\t\t(\n\n\t\t\t// Fall back to offsetWidth/offsetHeight when value is \"auto\"\n\t\t\t// This happens for inline elements with no explicit setting (gh-3571)\n\t\t\tval === \"auto\" ||\n\n\t\t\t// Support: IE 9 - 11+\n\t\t\t// Use offsetWidth/offsetHeight for when box sizing is unreliable.\n\t\t\t// In those cases, the computed value can be trusted to be border-box.\n\t\t\t( isIE && isBorderBox ) ||\n\n\t\t\t( !support.reliableColDimensions() && nodeName( elem, \"col\" ) ) ||\n\n\t\t\t( !support.reliableTrDimensions() && nodeName( elem, \"tr\" ) )\n\t\t) &&\n\n\t\t// Make sure the element is visible & connected\n\t\telem.getClientRects().length ) {\n\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t\t// Where available, offsetWidth/offsetHeight approximate border box dimensions.\n\t\t// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n\t\t// retrieved value as a content box dimension.\n\t\tvalueIsBorderBox = offsetProp in elem;\n\t\tif ( valueIsBorderBox ) {\n\t\t\tval = elem[ offsetProp ];\n\t\t}\n\t}\n\n\t// Normalize \"\" and auto\n\tval = parseFloat( val ) || 0;\n\n\t// Adjust for the element's box model\n\treturn ( val +\n\t\tboxModelAdjustment(\n\t\t\telem,\n\t\t\tdimension,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles,\n\n\t\t\t// Provide the current computed size to request scroll gutter calculation (gh-3589)\n\t\t\tval\n\t\t)\n\t) + \"px\";\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = cssCamelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name ),\n\t\t\tstyle = elem.style;\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to query the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (trac-7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug trac-9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (trac-7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If the value is a number, add `px` for certain CSS properties\n\t\t\tif ( type === \"number\" ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( isAutoPx( origName ) ? \"px\" : \"\" );\n\t\t\t}\n\n\t\t\t// Support: IE <=9 - 11+\n\t\t\t// background-* props of a cloned element affect the source element (trac-8908)\n\t\t\tif ( isIE && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tif ( isCustomProp ) {\n\t\t\t\t\tstyle.setProperty( name, value );\n\t\t\t\t} else {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t}\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = cssCamelCase( name ),\n\t\t\tisCustomProp = rcustomProp.test( name );\n\n\t\t// Make sure that we're working with the right name. We don't\n\t\t// want to modify the value if it is a CSS custom property\n\t\t// since they are user-defined.\n\t\tif ( !isCustomProp ) {\n\t\t\tname = finalPropName( origName );\n\t\t}\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( _i, dimension ) {\n\tjQuery.cssHooks[ dimension ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Elements with `display: none` can have dimension info if\n\t\t\t\t// we invisibly show them.\n\t\t\t\treturn jQuery.css( elem, \"display\" ) === \"none\" ?\n\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\treturn getWidthOrHeight( elem, dimension, extra );\n\t\t\t\t\t} ) :\n\t\t\t\t\tgetWidthOrHeight( elem, dimension, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = getStyles( elem ),\n\n\t\t\t\t// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n\t\t\t\tisBorderBox = extra &&\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\tsubtract = extra ?\n\t\t\t\t\tboxModelAdjustment(\n\t\t\t\t\t\telem,\n\t\t\t\t\t\tdimension,\n\t\t\t\t\t\textra,\n\t\t\t\t\t\tisBorderBox,\n\t\t\t\t\t\tstyles\n\t\t\t\t\t) :\n\t\t\t\t\t0;\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ dimension ] = value;\n\t\t\t\tvalue = jQuery.css( elem, dimension );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( prefix !== \"margin\" ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( Array.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t}\n} );\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( isAutoPx( prop ) ? \"px\" : \"\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 && (\n\t\t\t\tjQuery.cssHooks[ tween.prop ] ||\n\t\t\t\t\ttween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back compat <1.8 extension point\njQuery.fx.step = {};\n\nvar\n\tfxNow, inProgress,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\nfunction schedule() {\n\tif ( inProgress ) {\n\t\tif ( document$1.hidden === false && window.requestAnimationFrame ) {\n\t\t\twindow.requestAnimationFrame( schedule );\n\t\t} else {\n\t\t\twindow.setTimeout( schedule, 13 );\n\t\t}\n\n\t\tjQuery.fx.tick();\n\t}\n}\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = Date.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\tvar prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,\n\t\tisBox = \"width\" in props || \"height\" in props,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHiddenWithinTree( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Queue-skipping animations hijack the fx hooks\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Detect show/hide animations\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.test( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// Pretend to be hidden if this is a \"show\" and\n\t\t\t\t// there is still data from a stopped show/hide\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\n\t\t\t\t// Ignore all other no-op show/hide data\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\t\t}\n\t}\n\n\t// Bail out if this is a no-op like .hide().hide()\n\tpropTween = !jQuery.isEmptyObject( props );\n\tif ( !propTween && jQuery.isEmptyObject( orig ) ) {\n\t\treturn;\n\t}\n\n\t// Restrict \"overflow\" and \"display\" styles during box animations\n\tif ( isBox && elem.nodeType === 1 ) {\n\n\t\t// Support: IE <=9 - 11+\n\t\t// Record all 3 overflow attributes because IE does not infer the shorthand\n\t\t// from identically-valued overflowX and overflowY.\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Identify a display type, preferring old show/hide data over the CSS cascade\n\t\trestoreDisplay = dataShow && dataShow.display;\n\t\tif ( restoreDisplay == null ) {\n\t\t\trestoreDisplay = dataPriv.get( elem, \"display\" );\n\t\t}\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\tif ( display === \"none\" ) {\n\t\t\tif ( restoreDisplay ) {\n\t\t\t\tdisplay = restoreDisplay;\n\t\t\t} else {\n\n\t\t\t\t// Get nonempty value(s) by temporarily forcing visibility\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t\trestoreDisplay = elem.style.display || restoreDisplay;\n\t\t\t\tdisplay = jQuery.css( elem, \"display\" );\n\t\t\t\tshowHide( [ elem ] );\n\t\t\t}\n\t\t}\n\n\t\t// Animate inline elements as inline-block\n\t\tif ( display === \"inline\" || display === \"inline-block\" && restoreDisplay != null ) {\n\t\t\tif ( jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t\t// Restore the original display value at the end of pure show/hide animations\n\t\t\t\tif ( !propTween ) {\n\t\t\t\t\tanim.done( function() {\n\t\t\t\t\t\tstyle.display = restoreDisplay;\n\t\t\t\t\t} );\n\t\t\t\t\tif ( restoreDisplay == null ) {\n\t\t\t\t\t\tdisplay = style.display;\n\t\t\t\t\t\trestoreDisplay = display === \"none\" ? \"\" : display;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// Implement show/hide animations\n\tpropTween = false;\n\tfor ( prop in orig ) {\n\n\t\t// General show/hide setup for this element animation\n\t\tif ( !propTween ) {\n\t\t\tif ( dataShow ) {\n\t\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\t\thidden = dataShow.hidden;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdataShow = dataPriv.set( elem, \"fxshow\", { display: restoreDisplay } );\n\t\t\t}\n\n\t\t\t// Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\t\t\tif ( toggle ) {\n\t\t\t\tdataShow.hidden = !hidden;\n\t\t\t}\n\n\t\t\t// Show elements before animating them\n\t\t\tif ( hidden ) {\n\t\t\t\tshowHide( [ elem ], true );\n\t\t\t}\n\n\t\t\t// eslint-disable-next-line no-loop-func\n\t\t\tanim.done( function() {\n\n\t\t\t\t// The final step of a \"hide\" animation is actually hiding the element\n\t\t\t\tif ( !hidden ) {\n\t\t\t\t\tshowHide( [ elem ] );\n\t\t\t\t}\n\t\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\t\tfor ( prop in orig ) {\n\t\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\t// Per-property setup\n\t\tpropTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\t\tif ( !( prop in dataShow ) ) {\n\t\t\tdataShow[ prop ] = propTween.start;\n\t\t\tif ( hidden ) {\n\t\t\t\tpropTween.end = propTween.start;\n\t\t\t\tpropTween.start = 0;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = cssCamelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( Array.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\tpercent = 1 - ( remaining / animation.duration || 0 ),\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\t// If there's more to do, yield\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t}\n\n\t\t\t// If this was an empty animation, synthesize a final progress notification\n\t\t\tif ( !length ) {\n\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t}\n\n\t\t\t// Resolve the animation and report its conclusion\n\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\treturn false;\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( typeof result.stop === \"function\" ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tresult.stop.bind( result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( typeof animation.opts.start === \"function\" ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\t// Attach callbacks from options\n\tanimation\n\t\t.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\treturn animation;\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( typeof props === \"function\" ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnothtmlwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || easing ||\n\t\t\ttypeof speed === \"function\" && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && typeof easing !== \"function\" && easing\n\t};\n\n\t// Go to the end state if fx are off\n\tif ( jQuery.fx.off ) {\n\t\topt.duration = 0;\n\n\t} else {\n\t\tif ( typeof opt.duration !== \"number\" ) {\n\t\t\tif ( opt.duration in jQuery.fx.speeds ) {\n\t\t\t\topt.duration = jQuery.fx.speeds[ opt.duration ];\n\n\t\t\t} else {\n\t\t\t\topt.duration = jQuery.fx.speeds._default;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( typeof opt.old === \"function\" ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHiddenWithinTree ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\n\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( _i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = Date.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Run the timer and safely remove it when done (allowing for external removal)\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tjQuery.fx.start();\n};\n\njQuery.fx.start = function() {\n\tif ( inProgress ) {\n\t\treturn;\n\t}\n\n\tinProgress = true;\n\tschedule();\n};\n\njQuery.fx.stop = function() {\n\tinProgress = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n// Based off of the plugin by Clint Helfers, with permission.\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// Support: IE <=9 - 11+\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// Use proper attribute retrieval (trac-12072)\n\t\t\t\tvar tabindex = elem.getAttribute( \"tabindex\" );\n\n\t\t\t\tif ( tabindex ) {\n\t\t\t\t\treturn parseInt( tabindex, 10 );\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\n\t\t\t\t\t// href-less anchor's `tabIndex` property value is `0` and\n\t\t\t\t\t// the `tabindex` attribute value: `null`. We want `-1`.\n\t\t\t\t\trclickable.test( elem.nodeName ) && elem.href\n\t\t\t\t) {\n\t\t\t\t\treturn 0;\n\t\t\t\t}\n\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11+\n// Accessing the selectedIndex property forces the browser to respect\n// setting selected on the option. The getter ensures a default option\n// is selected when in an optgroup. ESLint rule \"no-unused-expressions\"\n// is disabled for this code since it considers such accessions noop.\nif ( isIE ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\n\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n// Strip and collapse whitespace according to HTML spec\n// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\nfunction stripAndCollapse( value ) {\n\tvar tokens = value.match( rnothtmlwhite ) || [];\n\treturn tokens.join( \" \" );\n}\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\nfunction classesToArray( value ) {\n\tif ( Array.isArray( value ) ) {\n\t\treturn value;\n\t}\n\tif ( typeof value === \"string\" ) {\n\t\treturn value.match( rnothtmlwhite ) || [];\n\t}\n\treturn [];\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( typeof value === \"function\" ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + className + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += className + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classNames, cur, curValue, className, i, finalValue;\n\n\t\tif ( typeof value === \"function\" ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tcurValue = getClass( this );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = this.nodeType === 1 && ( \" \" + stripAndCollapse( curValue ) + \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + className + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + className + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = stripAndCollapse( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\tthis.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar classNames, className, i, self;\n\n\t\tif ( typeof value === \"function\" ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof stateVal === \"boolean\" ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tclassNames = classesToArray( value );\n\n\t\tif ( classNames.length ) {\n\t\t\treturn this.each( function() {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\tself = jQuery( this );\n\n\t\t\t\tfor ( i = 0; i < classNames.length; i++ ) {\n\t\t\t\t\tclassName = classNames[ i ];\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + stripAndCollapse( getClass( elem ) ) + \" \" ).indexOf( className ) > -1 ) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, valueIsFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\treturn ret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tvalueIsFunction = typeof value === \"function\";\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( valueIsFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( Array.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option, i,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\",\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length;\n\n\t\t\t\tif ( index < 0 ) {\n\t\t\t\t\ti = max;\n\n\t\t\t\t} else {\n\t\t\t\t\ti = one ? index : 0;\n\t\t\t\t}\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\tif ( option.selected &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t!option.disabled &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\tif ( ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery( option ).val(), values ) > -1\n\t\t\t\t\t) ) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\nif ( isIE ) {\n\tjQuery.valHooks.option = {\n\t\tget: function( elem ) {\n\n\t\t\tvar val = elem.getAttribute( \"value\" );\n\t\t\treturn val != null ?\n\t\t\t\tval :\n\n\t\t\t\t// Support: IE <=10 - 11+\n\t\t\t\t// option.text throws exceptions (trac-14686, trac-14858)\n\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\tstripAndCollapse( jQuery.text( elem ) );\n\t\t}\n\t};\n}\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( Array.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n} );\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n\tstopPropagationCallback = function( e ) {\n\t\te.stopPropagation();\n\t};\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special, lastElement,\n\t\t\teventPath = [ elem || document$1 ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = lastElement = tmp = elem = elem || document$1;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (trac-9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document$1 ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tlastElement = cur;\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || Object.create( null ) )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (trac-6170)\n\t\t\t\tif ( ontype && typeof elem[ type ] === \"function\" && !isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.addEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\telem[ type ]();\n\n\t\t\t\t\tif ( event.isPropagationStopped() ) {\n\t\t\t\t\t\tlastElement.removeEventListener( type, stopPropagationCallback );\n\t\t\t\t\t}\n\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\nvar location = window.location;\n\nvar nonce = { guid: Date.now() };\n\nvar rquery = /\\?/;\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, parserErrorElem;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE 9 - 11+\n\t// IE throws on parseFromString with invalid input.\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {}\n\n\tparserErrorElem = xml && xml.getElementsByTagName( \"parsererror\" )[ 0 ];\n\tif ( !xml || parserErrorElem ) {\n\t\tjQuery.error( \"Invalid XML: \" + (\n\t\t\tparserErrorElem ?\n\t\t\t\tjQuery.map( parserErrorElem.childNodes, function( el ) {\n\t\t\t\t\treturn el.textContent;\n\t\t\t\t} ).join( \"\\n\" ) :\n\t\t\t\tdata\n\t\t) );\n\t}\n\treturn xml;\n};\n\nvar\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( Array.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && toType( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, valueOrFunction ) {\n\n\t\t\t// If value is a function, invoke it and use its return value\n\t\t\tvar value = typeof valueOrFunction === \"function\" ?\n\t\t\t\tvalueOrFunction() :\n\t\t\t\tvalueOrFunction;\n\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" +\n\t\t\t\tencodeURIComponent( value == null ? \"\" : value );\n\t\t};\n\n\tif ( a == null ) {\n\t\treturn \"\";\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} ).filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} ).map( function( _i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\tif ( val == null ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\treturn jQuery.map( val, function( val ) {\n\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\nvar\n\tr20 = /%20/g,\n\trhash = /#.*$/,\n\trantiCache = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// trac-7653, trac-8125, trac-8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t * - BEFORE asking for a transport\n\t * - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document$1.createElement( \"a\" );\n\noriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];\n\n\t\tif ( typeof func === \"function\" ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes trac-9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": JSON.parse,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// Request state (becomes false upon send and true upon completion)\n\t\t\tcompleted,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// uncached part of the url\n\t\t\tuncached,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( completed ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\n\t\t\t\t\t\t\t\t// Support: IE 11+\n\t\t\t\t\t\t\t\t// `getResponseHeader( key )` in IE doesn't combine all header\n\t\t\t\t\t\t\t\t// values for the provided key into a single result with values\n\t\t\t\t\t\t\t\t// joined by commas as other browsers do. Instead, it returns\n\t\t\t\t\t\t\t\t// them on separate lines.\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() + \" \" ] =\n\t\t\t\t\t\t\t\t\t( responseHeaders[ match[ 1 ].toLowerCase() + \" \" ] || [] )\n\t\t\t\t\t\t\t\t\t\t.concat( match[ 2 ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() + \" \" ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match.join( \", \" );\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn completed ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\tname = requestHeadersNames[ name.toLowerCase() ] =\n\t\t\t\t\t\t\trequestHeadersNames[ name.toLowerCase() ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( completed == null ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( completed ) {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Lazy-add the new callbacks in a way that preserves old ones\n\t\t\t\t\t\t\tfor ( code in map ) {\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR );\n\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (trac-10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket trac-12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = ( s.dataType || \"*\" ).toLowerCase().match( rnothtmlwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document$1.createElement( \"a\" );\n\n\t\t\t// Support: IE <=8 - 11+\n\t\t\t// IE throws exception on accessing the href property if url is malformed,\n\t\t\t// e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE <=8 - 11+\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( completed ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an ESM-usage scenario (trac-15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\t// Remove hash to simplify url manipulation\n\t\tcacheURL = s.url.replace( rhash, \"\" );\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// Remember the hash so we can put it back\n\t\t\tuncached = s.url.slice( cacheURL.length );\n\n\t\t\t// If data is available and should be processed, append data to url\n\t\t\tif ( s.data && ( s.processData || typeof s.data === \"string\" ) ) {\n\t\t\t\tcacheURL += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data;\n\n\t\t\t\t// trac-9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add or update anti-cache param if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\tcacheURL = cacheURL.replace( rantiCache, \"$1\" );\n\t\t\t\tuncached = ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" +\n\t\t\t\t\t( nonce.guid++ ) + uncached;\n\t\t\t}\n\n\t\t\t// Put hash and anti-cache on the URL that will be requested (gh-1732)\n\t\t\ts.url = cacheURL + uncached;\n\n\t\t// Change '%20' to '+' if this is encoded form body content (gh-2658)\n\t\t} else if ( s.data && s.processData &&\n\t\t\t( s.contentType || \"\" ).indexOf( \"application/x-www-form-urlencoded\" ) === 0 ) {\n\t\t\ts.data = s.data.replace( r20, \"+\" );\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tcompleteDeferred.add( s.complete );\n\t\tjqXHR.done( s.success );\n\t\tjqXHR.fail( s.error );\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( completed ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tcompleted = false;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Rethrow post-completion exceptions\n\t\t\t\tif ( completed ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\n\t\t\t\t// Propagate others as results\n\t\t\t\tdone( -1, e );\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Ignore repeat invocations\n\t\t\tif ( completed ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcompleted = true;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Use a noop converter for missing script but not if jsonp\n\t\t\tif ( !isSuccess &&\n\t\t\t\tjQuery.inArray( \"script\", s.dataTypes ) > -1 &&\n\t\t\t\tjQuery.inArray( \"json\", s.dataTypes ) < 0 ) {\n\t\t\t\ts.converters[ \"text script\" ] = function() {};\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( _i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted.\n\t\t// Handle the null callback placeholder.\n\t\tif ( typeof data === \"function\" || data === null ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\njQuery.ajaxPrefilter( function( s ) {\n\tvar i;\n\tfor ( i in s.headers ) {\n\t\tif ( i.toLowerCase() === \"content-type\" ) {\n\t\t\ts.contentType = s.headers[ i ] || \"\";\n\t\t}\n\t}\n} );\n\njQuery._evalUrl = function( url, options, doc ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (trac-11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tcache: true,\n\t\tasync: false,\n\t\tglobal: false,\n\t\tscriptAttrs: options.crossOrigin ? { \"crossOrigin\": options.crossOrigin } : undefined,\n\n\t\t// Only evaluate the response if it is successful (gh-4126)\n\t\t// dataFilter is not invoked for failure responses, so using it instead\n\t\t// of the default converter is kludgy but it works.\n\t\tconverters: {\n\t\t\t\"text script\": function() {}\n\t\t},\n\t\tdataFilter: function( response ) {\n\t\t\tjQuery.globalEval( response, options, doc );\n\t\t}\n\t} );\n};\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( this[ 0 ] ) {\n\t\t\tif ( typeof html === \"function\" ) {\n\t\t\t\thtml = html.call( this[ 0 ] );\n\t\t\t}\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( typeof html === \"function\" ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar htmlIsFunction = typeof html === \"function\";\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function( selector ) {\n\t\tthis.parent( selector ).not( \"body\" ).each( function() {\n\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t} );\n\t\treturn this;\n\t}\n} );\n\njQuery.expr.pseudos.hidden = function( elem ) {\n\treturn !jQuery.expr.pseudos.visible( elem );\n};\njQuery.expr.pseudos.visible = function( elem ) {\n\treturn !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );\n};\n\njQuery.ajaxSettings.xhr = function() {\n\treturn new window.XMLHttpRequest();\n};\n\nvar xhrSuccessStatus = {\n\n\t// File protocol always yields status code 0, assume 200\n\t0: 200\n};\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback;\n\n\treturn {\n\t\tsend: function( headers, complete ) {\n\t\t\tvar i,\n\t\t\t\txhr = options.xhr();\n\n\t\t\txhr.open(\n\t\t\t\toptions.type,\n\t\t\t\toptions.url,\n\t\t\t\toptions.async,\n\t\t\t\toptions.username,\n\t\t\t\toptions.password\n\t\t\t);\n\n\t\t\t// Apply custom fields if provided\n\t\t\tif ( options.xhrFields ) {\n\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override mime type if needed\n\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t}\n\n\t\t\t// X-Requested-With header\n\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t}\n\n\t\t\t// Set headers\n\t\t\tfor ( i in headers ) {\n\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t}\n\n\t\t\t// Callback\n\t\t\tcallback = function( type ) {\n\t\t\t\treturn function() {\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tcallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = null;\n\n\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see trac-8605, trac-14207\n\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) === \"text\" ?\n\t\t\t\t\t\t\t\t\t{ text: xhr.responseText } :\n\t\t\t\t\t\t\t\t\t{ binary: xhr.response },\n\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\n\t\t\t// Listen to events\n\t\t\txhr.onload = callback();\n\t\t\txhr.onabort = xhr.onerror = xhr.ontimeout = callback( \"error\" );\n\n\t\t\t// Create the abort callback\n\t\t\tcallback = callback( \"abort\" );\n\n\t\t\ttry {\n\n\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// trac-14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\tabort: function() {\n\t\t\tif ( callback ) {\n\t\t\t\tcallback();\n\t\t\t}\n\t\t}\n\t};\n} );\n\nfunction canUseScriptTag( s ) {\n\n\t// A script tag can only be used for async, cross domain or forced-by-attrs requests.\n\t// Requests with headers cannot use a script tag. However, when both `scriptAttrs` &\n\t// `headers` options are specified, both are impossible to satisfy together; we\n\t// prefer `scriptAttrs` then.\n\t// Sync requests remain handled differently to preserve strict script ordering.\n\treturn s.scriptAttrs || (\n\t\t!s.headers &&\n\t\t(\n\t\t\ts.crossDomain ||\n\n\t\t\t// When dealing with JSONP (`s.dataTypes` include \"json\" then)\n\t\t\t// don't use a script tag so that error responses still may have\n\t\t\t// `responseJSON` set. Continue using a script tag for JSONP requests that:\n\t\t\t// * are cross-domain as AJAX requests won't work without a CORS setup\n\t\t\t// * have `scriptAttrs` set as that's a script-only functionality\n\t\t\t// Note that this means JSONP requests violate strict CSP script-src settings.\n\t\t\t// A proper solution is to migrate from using JSONP to a CORS setup.\n\t\t\t( s.async && jQuery.inArray( \"json\", s.dataTypes ) < 0 )\n\t\t)\n\t);\n}\n\n// Install script dataType. Don't specify `contents.script` so that an explicit\n// `dataType: \"script\"` is required (see gh-2432, gh-4822)\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\n\t// These types of requests are handled via a script tag\n\t// so force their methods to GET.\n\tif ( canUseScriptTag( s ) ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\tif ( canUseScriptTag( s ) ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"\n \n \n `);\n document.close();\n}\n\nconst delay = (ms: number) => new Promise((resolve) => { setTimeout(resolve, ms); });\n\nexport async function restartReload(initial = true) {\n document.body.style = 'background: #222222; font-size: 1rem; font-family:monospace; margin-top:20%; color:lightgray; text-align:center';\n document.body.innerHTML = '

    Server shutdown in progress...

    ';\n if (initial) await delay(10000);\n try {\n const res = await authFetch(`${window.api}/progress?skip_current_image=true`);\n console.log('restartReload', res);\n if (res?.ok) {\n document.body.innerHTML = '

    Server restart in progress...

    ';\n setTimeout(() => location.reload(), 10000);\n } else {\n setTimeout(() => restartReload(false), 2500);\n }\n } catch {\n setTimeout(() => restartReload(false), 2500);\n }\n return [];\n}\n\nexport function updateInput(target) {\n const e = new Event('input', { bubbles: true });\n Object.defineProperty(e, 'target', { value: target });\n target.dispatchEvent(e);\n}\n\nlet desiredCheckpointName = null;\nexport function selectCheckpoint(name) {\n desiredCheckpointName = name;\n const tabName = getENActiveTab();\n const btnModel = gradioApp().getElementById(`${tabName}_extra_model`);\n const isRefiner = btnModel && btnModel.classList.contains('toolbutton-selected');\n if (isRefiner) gradioApp().getElementById('change_refiner').click();\n else gradioApp().getElementById('change_checkpoint').click();\n log(`selectCheckpoint ${isRefiner ? 'refiner' : 'model'}: ${desiredCheckpointName}`);\n markSelectedCards([desiredCheckpointName], 'model');\n setTimeout(requestProgress, 250);\n}\n\nlet desiredVAEName = null;\nexport function selectVAE(name) {\n desiredVAEName = name;\n gradioApp().getElementById('change_vae').click();\n log(`selectVAE: ${desiredVAEName}`);\n markSelectedCards([desiredVAEName], 'vae');\n}\n\nlet desiredUNetName = null;\n\nfunction consumeDesiredCheckpointName(v) {\n const res = desiredCheckpointName;\n desiredCheckpointName = null;\n return [res || v, null];\n}\n\nfunction consumeDesiredVAEName(v) {\n const res = desiredVAEName;\n desiredVAEName = null;\n return [res || v, null];\n}\n\nfunction consumeDesiredUNetName(v) {\n const res = desiredUNetName;\n desiredUNetName = null;\n return [res || v, null];\n}\n\nfunction getDesiredCheckpointName() {\n return desiredCheckpointName;\n}\n\nexport function selectUNet(name) {\n desiredUNetName = name;\n const tabName = getENActiveTab();\n const btnModel = gradioApp().getElementById(`${tabName}_extra_model`);\n const isSecondary = btnModel && btnModel.classList.contains('toolbutton-selected');\n if (isSecondary) gradioApp().getElementById('change_unet_secondary').click();\n else gradioApp().getElementById('change_unet').click();\n log(`selectUNet ${isSecondary ? 'secondary' : 'primary'}: ${desiredUNetName}`);\n markSelectedCards([desiredUNetName], 'unet');\n}\n\nexport function selectReference(name) {\n log(`selectReference: ${name}`);\n desiredCheckpointName = name;\n gradioApp().getElementById('change_reference').click();\n markSelectedCards([desiredCheckpointName], 'model');\n setTimeout(requestProgress, 250);\n}\n\nfunction currentImageResolutionimg2img(_a, _b, scaleBy) {\n const img = gradioApp().querySelector('#mode_img2img > div[style=\"display: block;\"] img');\n return img ? [img.naturalWidth, img.naturalHeight, scaleBy] : [0, 0, scaleBy];\n}\n\nfunction currentImageResolutioncontrol(_a, _b, scaleBy) {\n if (window.kanvas) {\n const active = window.kanvas.stages?.getActiveStage();\n return [active?.width || 0, active?.height || 0, scaleBy];\n }\n const img = gradioApp().querySelector('#control-tab-input > div[style=\"display: block;\"] img');\n return img ? [img.naturalWidth, img.naturalHeight, scaleBy] : [0, 0, scaleBy];\n}\n\nfunction updateImg2imgResizeToTextAfterChangingImage() {\n const el = gradioApp().getElementById('img2img_update_resize_to');\n if (el) setTimeout(() => gradioApp().getElementById('img2img_update_resize_to').click(), 500);\n return [];\n}\n\nfunction createThemeElement(): HTMLImageElement {\n const el = document.createElement('img');\n el.id = 'theme-preview';\n el.className = 'theme-preview';\n el.onclick = () => { el.style.display = 'none'; };\n document.body.appendChild(el);\n return el;\n}\n\nexport async function toggleCompact(val, old) {\n if (val === old) return;\n log('toggleCompact', val, old);\n if (val) {\n gradioApp().style.setProperty('--layout-gap', 'var(--spacing-md)');\n gradioApp().querySelectorAll('input[type=range]').forEach((el) => el.classList.add('hidden'));\n gradioApp().querySelectorAll('div .form').forEach((el) => el.classList.add('form-compact'));\n gradioApp().querySelectorAll('.small-accordion .label-wrap').forEach((el) => el.classList.add('accordion-compact'));\n } else {\n gradioApp().style.setProperty('--layout-gap', 'var(--spacing-xxl)');\n gradioApp().querySelectorAll('input[type=range]').forEach((el) => el.classList.remove('hidden'));\n gradioApp().querySelectorAll('div .form').forEach((el) => el.classList.remove('form-compact'));\n gradioApp().querySelectorAll('.small-accordion .label-wrap').forEach((el) => el.classList.remove('accordion-compact'));\n }\n}\n\nfunction previewTheme() {\n let name = gradioApp().getElementById('setting_gradio_theme').querySelectorAll('input')?.[0].value || '';\n fetch(`${window.subpath}/file=data/themes.json`)\n .then((res) => {\n res.json()\n .then((themes) => {\n const theme = Array.isArray(themes) ? themes.find((t) => t.id === name) : null;\n if (theme) {\n window.open(theme.subdomain, '_blank');\n } else {\n const el = document.getElementById('theme-preview') as HTMLImageElement | null || createThemeElement();\n el.style.display = el.style.display === 'block' ? 'none' : 'block';\n name = name.replace('/', '-');\n el.src = `/file=ui/css/${name}.jpg`;\n }\n })\n .catch((e) => error(`previewTheme: ${e}`));\n })\n .catch((e) => error(`previewTheme: ${e}`));\n}\n\nasync function browseFolder() {\n const picker = window.showDirectoryPicker?.();\n if (!picker) return null;\n const f = await picker;\n if (f && f.kind === 'directory') return f.name;\n return null;\n}\n\nlet kanvasNotifyTimer: ReturnType | undefined;\n// Notify kanvas to resize its stage when the resize-panel width/height change. Wired through gradio's\n// .change so it also fires on programmatic updates (detect-size, paste params, swap, send-to) that the\n// client-side resolutionLock input listeners never see. Writes nothing back, so it cannot loop.\nexport function notifyKanvasResize(width: number, height: number) {\n if (window.resizeStage) {\n const w = Number(width);\n const h = Number(height);\n clearTimeout(kanvasNotifyTimer);\n kanvasNotifyTimer = setTimeout(() => window.resizeStage?.(w, h), 250);\n }\n}\n\nexport async function reconnectUI() {\n const t0 = performance.now();\n const gallery = gradioApp().getElementById('txt2img_gallery');\n const task_id = localStorage.getItem('task');\n const api_logo = Array.from(gradioApp().querySelectorAll('img')).filter((el) => el.src.endsWith('api-logo.svg'));\n if (api_logo.length > 0) api_logo[0].remove();\n if (task_id) {\n debug('task check:', task_id);\n requestProgress(task_id, null, gallery, null, null, true);\n }\n uiLoaded = true;\n\n const sd_model = gradioApp().getElementById('setting_sd_model_checkpoint');\n let loadingStarted = 0;\n let loadingMonitor: ReturnType | null = null;\n\n const sd_model_callback = () => {\n const loading = sd_model.querySelector('.eta-bar');\n if (!loading) {\n loadingStarted = 0;\n clearInterval(loadingMonitor);\n } else if (loadingStarted === 0) {\n loadingStarted = Date.now();\n loadingMonitor = setInterval(() => {\n const elapsed = Date.now() - loadingStarted;\n if (elapsed > 3000 && loading) loading.style.display = 'none';\n }, 5000);\n }\n };\n const sd_model_observer = new MutationObserver(sd_model_callback);\n sd_model_observer.observe(sd_model, { attributes: true, childList: true, subtree: true });\n const t1 = performance.now();\n log('reconnectUI', Math.round(t1 - t0));\n timer('reconnectUI', t1 - t0);\n}\n\nwindow.restartReload = restartReload;\nwindow.updateInput = updateInput;\nwindow.notifyKanvasResize = notifyKanvasResize;\nwindow.clip_gallery_urls = clip_gallery_urls;\nwindow.extract_image_from_gallery = extract_image_from_gallery;\nwindow.getCaptionActiveTab = getCaptionActiveTab;\nwindow.get_img2img_tab_index = get_img2img_tab_index;\nwindow.modelmerger = modelmerger;\nwindow.selected_gallery_index = selected_gallery_index;\nwindow.selected_gallery_files = selected_gallery_files;\nwindow.send_to_kanvas = send_to_kanvas;\nwindow.submit_control = submit_control;\nwindow.submit_framepack = submit_framepack;\nwindow.submit_img2img = submit_img2img;\nwindow.submit_ltx = submit_ltx;\nwindow.submit_postprocessing = submit_postprocessing;\nwindow.submit = submit_txt2img; // compatibility alias\nwindow.submit_txt2img = submit_txt2img;\nwindow.submit_video = submit_video;\nwindow.submit_video_wrapper = submit_video_wrapper;\nwindow.switch_to_txt2img = switch_to_txt2img;\nwindow.switch_to_img2img_tab = switch_to_img2img_tab;\nwindow.switch_to_img2img = switch_to_img2img;\nwindow.switch_to_inpaint = switch_to_inpaint;\nwindow.switch_to_sketch = switch_to_sketch;\nwindow.switch_to_composite = switch_to_composite;\nwindow.switch_to_extras = switch_to_extras;\nwindow.switch_to_control = switch_to_control;\nwindow.switch_to_video = switch_to_video;\nwindow.switch_to_caption = switch_to_caption;\nwindow.recalculate_prompts_txt2img = recalculate_prompts_txt2img;\nwindow.recalculate_prompts_img2img = recalculate_prompts_img2img;\nwindow.recalculate_prompts_inpaint = recalculate_prompts_inpaint;\nwindow.recalculate_prompts_control = recalculate_prompts_control;\nwindow.selectCheckpoint = selectCheckpoint;\nwindow.selectVAE = selectVAE;\nwindow.selectUNet = selectUNet;\nwindow.selectReference = selectReference;\nwindow.consumeDesiredCheckpointName = consumeDesiredCheckpointName;\nwindow.consumeDesiredVAEName = consumeDesiredVAEName;\nwindow.consumeDesiredUNetName = consumeDesiredUNetName;\nwindow.getDesiredCheckpointName = getDesiredCheckpointName;\nwindow.currentImageResolutionimg2img = currentImageResolutionimg2img;\nwindow.currentImageResolutioncontrol = currentImageResolutioncontrol;\nwindow.updateImg2imgResizeToTextAfterChangingImage = updateImg2imgResizeToTextAfterChangingImage;\nwindow.create_submit_args = create_submit_args;\nwindow.set_theme = set_theme;\n", "import { gradioApp } from './script';\nimport { updateInput } from './ui';\n\ntype AccordionElement = HTMLElement & {\n visibleCheckbox: HTMLInputElement;\n onVisibleCheckboxChange: () => void;\n onChecked: (checked: boolean) => void;\n};\n\nexport function inputAccordionChecked(id: string, checked: boolean): void {\n const accordion = gradioApp().getElementById(id);\n if (!(accordion instanceof HTMLElement)) return;\n const acc = accordion as AccordionElement;\n acc.visibleCheckbox.checked = checked;\n acc.onVisibleCheckboxChange();\n}\n\nfunction setupAccordion(accordion: Element): void {\n if (!(accordion instanceof HTMLElement)) return;\n const acc = accordion as AccordionElement;\n const labelWrap = accordion.querySelector('.label-wrap');\n const gradioCheckbox = gradioApp().querySelector(`#${accordion.id}-checkbox input`);\n const extra = gradioApp().querySelector(`#${accordion.id}-extra`);\n if (!(labelWrap instanceof HTMLElement) || !(gradioCheckbox instanceof HTMLInputElement)) return;\n const span = labelWrap.querySelector('span');\n if (!(span instanceof HTMLElement)) return;\n let linked = true;\n const isOpen = () => labelWrap.classList.contains('open');\n const observerAccordionOpen = new MutationObserver((mutations) => {\n mutations.forEach((mutationRecord) => {\n accordion.classList.toggle('input-accordion-open', isOpen());\n if (linked) {\n acc.visibleCheckbox.checked = isOpen();\n acc.onVisibleCheckboxChange();\n }\n });\n });\n observerAccordionOpen.observe(labelWrap, { attributes: true, attributeFilter: ['class'] });\n if (extra instanceof Node) labelWrap.insertBefore(extra, labelWrap.lastElementChild);\n acc.onChecked = (checked: boolean) => {\n if (isOpen() !== checked) labelWrap.click();\n };\n\n const visibleCheckbox = document.createElement('INPUT');\n visibleCheckbox.type = 'checkbox';\n visibleCheckbox.checked = isOpen();\n visibleCheckbox.id = `${accordion.id}-visible-checkbox`;\n visibleCheckbox.className = `${gradioCheckbox.className} input-accordion-checkbox`;\n span.insertBefore(visibleCheckbox, span.firstChild);\n acc.visibleCheckbox = visibleCheckbox as any;\n acc.onVisibleCheckboxChange = () => {\n if (linked && isOpen() !== visibleCheckbox.checked) labelWrap.click();\n gradioCheckbox.checked = visibleCheckbox.checked;\n updateInput(gradioCheckbox);\n };\n\n visibleCheckbox.addEventListener('click', (event) => {\n linked = false;\n event.stopPropagation();\n });\n visibleCheckbox.addEventListener('input', acc.onVisibleCheckboxChange);\n}\n\nwindow.inputAccordionChecked = inputAccordionChecked;\n\n// onUiLoaded(() => {\n// for (const accordion of gradioApp().querySelectorAll('.input-accordion')) setupAccordion(accordion);\n// });\n\nexport function initAccordions() {\n for (const accordion of gradioApp().querySelectorAll('.input-accordion')) setupAccordion(accordion);\n}\n", "/**\n * @type {?IDBDatabase}\n */\nimport { log } from './logger';\n\nlet db = null;\n\ninterface ThumbRecord {\n hash: string;\n folder?: string;\n [key: string]: unknown;\n}\n\nexport async function initIndexDB(): Promise {\n async function createDB(): Promise {\n return new Promise((resolve, reject) => {\n const request = indexedDB.open('SDNext', 2);\n request.onerror = (evt: Event) => reject(evt);\n request.onsuccess = (evt: Event) => {\n db = (evt.target as IDBOpenDBRequest).result;\n const countAll = db\n .transaction(['thumbs'], 'readwrite')\n .objectStore('thumbs')\n .count();\n countAll.onsuccess = () => log('initIndexDB', countAll.result);\n resolve();\n };\n request.onupgradeneeded = (evt: IDBVersionChangeEvent) => {\n db = (evt.target as IDBOpenDBRequest).result;\n const oldver = evt.oldVersion;\n if (oldver < 1) {\n const store = db.createObjectStore('thumbs', { keyPath: 'hash' });\n store.createIndex('hash', 'hash', { unique: true });\n }\n if (oldver < 2) {\n const existingStore = request.transaction.objectStore('thumbs');\n existingStore.createIndex('folder', 'folder', { unique: false });\n }\n resolve();\n };\n });\n }\n\n if (!db) await createDB();\n}\n\nexport function idbIsReady(): boolean {\n return db !== null;\n}\n\n/**\n * Reusable setup for handling IDB transactions.\n * @param {Object} resources - Required resources for implementation\n * @param {IDBTransaction} resources.transaction\n * @param {AbortSignal} resources.signal\n * @param {Function} resources.resolve\n * @param {Function} resources.reject\n * @param {*} resolveValue - Value to resolve the outer Promise with\n * @returns {() => void} - Function for manually aborting the transaction\n */\nfunction configureTransactionAbort({\n transaction,\n signal,\n resolve,\n reject,\n}: {\n transaction: IDBTransaction;\n signal: AbortSignal;\n resolve: (value: T) => void;\n reject: (reason?: unknown) => void;\n}, resolveValue: T): () => void {\n function abortTransaction() {\n signal.removeEventListener('abort', abortTransaction);\n transaction.abort();\n }\n signal.addEventListener('abort', abortTransaction);\n transaction.onabort = () => {\n signal.removeEventListener('abort', abortTransaction);\n reject(new DOMException(`Aborting database transaction. ${signal.reason}`, 'AbortError'));\n };\n transaction.onerror = (e) => {\n signal.removeEventListener('abort', abortTransaction);\n reject(new Error('Database transaction error.'));\n };\n transaction.oncomplete = () => {\n signal.removeEventListener('abort', abortTransaction);\n resolve(resolveValue);\n };\n return abortTransaction;\n}\n\nasync function add(record: ThumbRecord): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readwrite')\n .objectStore('thumbs')\n .add(record);\n request.onsuccess = (evt) => resolve(evt);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nasync function del(hash: string): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readwrite')\n .objectStore('thumbs')\n .delete(hash);\n request.onsuccess = (evt) => resolve(evt);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nasync function get(hash: string): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readonly')\n .objectStore('thumbs')\n .index('hash')\n .get(hash);\n request.onsuccess = () => resolve(request.result);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nasync function getKeys(hash: string): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readonly')\n .objectStore('thumbs')\n .index('hash')\n .getAllKeys();\n request.onsuccess = () => resolve(request.result);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nasync function put(record: ThumbRecord): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const request = db\n .transaction(['thumbs'], 'readwrite')\n .objectStore('thumbs')\n .put(record);\n request.onsuccess = (evt) => resolve(evt);\n request.onerror = (evt) => reject(evt);\n });\n}\n\nexport async function idbGetAllKeys(index: string | null = null, query: IDBValidKey | IDBKeyRange | null = null): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n try {\n let request;\n const transaction = db.transaction('thumbs', 'readonly');\n transaction.onabort = (e) => reject(e);\n const store = transaction.objectStore('thumbs');\n if (index) request = store.index(index).getAllKeys(query);\n else request = store.getAllKeys(query);\n request.onsuccess = () => resolve(request.result);\n request.onerror = (e) => reject(e);\n } catch (err) {\n reject(err);\n }\n });\n}\n\n/**\n * Get the number of entries in the IndexedDB thumbnail cache.\n * @global\n * @param {IDBValidKey | IDBKeyRange | undefined} folder - If specified, get the count for this gallery folder. Otherwise get the total count.\n * @returns {Promise}\n */\nexport async function idbCount(folder?: IDBValidKey | IDBKeyRange): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n try {\n let request;\n const transaction = db.transaction('thumbs', 'readonly');\n transaction.onabort = (e) => reject(e);\n const store = transaction.objectStore('thumbs');\n if (folder) request = store.index('folder').count(folder);\n else request = store.count();\n request.onsuccess = () => resolve(request.result);\n request.onerror = (e) => reject(e);\n } catch (err) {\n reject(err);\n }\n });\n}\n\n/**\n * Cleanup function for IndexedDB thumbnail cache.\n * @global\n * @param {Set} keepSet - Set containing the hashes of the current files in the folder\n * @param {IDBValidKey | IDBKeyRange} folder - Folder name/path or range\n * @param {AbortSignal} signal - Signal from the AbortController for thumbCacheCleanup()\n */\nexport async function idbFolderCleanup(keepSet: Set, folder: IDBValidKey | IDBKeyRange, signal: AbortSignal): Promise {\n if (!db) return null;\n const existing = await idbGetAllKeys('folder', folder);\n const removals = new Set((existing ?? []).map((entry) => String(entry)).filter((entry) => !keepSet.has(entry))); // Don't need to keep full set in memory\n const totalRemovals = removals.size;\n if (signal.aborted) {\n throw new Error(`Aborting. ${String(signal.reason)}`);\n }\n return new Promise((resolve, reject) => {\n const transaction = db.transaction('thumbs', 'readwrite');\n const props = { transaction, signal, resolve, reject };\n configureTransactionAbort(props, totalRemovals);\n const store = transaction.objectStore('thumbs');\n removals.forEach((entry) => { store.delete(entry); });\n });\n}\n\nexport async function idbClearAll(signal: AbortSignal): Promise {\n if (!db) return null;\n return new Promise((resolve, reject) => {\n const transaction = db.transaction(['thumbs'], 'readwrite');\n const props = { transaction, signal, resolve, reject };\n configureTransactionAbort(props, null);\n transaction.objectStore('thumbs').clear();\n });\n}\n\nexport const idbAdd = add;\nexport const idbDel = del;\nexport const idbGet = get;\nexport const idbPut = put;\nexport const idbKeys = getKeys;\n", "import { authFetch } from './authWrap';\nimport { log, error, xhrPost } from './logger';\nimport { timer } from './timers';\n\ninterface LogLine {\n created: number;\n level: string;\n module: string;\n facility: string;\n msg: string;\n}\n\nlet logMonitorEl: HTMLElement | null = null;\nlet logMonitorStatus = true;\nlet logWarnings = 0;\nlet logErrors = 0;\nlet logConnected = false;\n\nfunction dateToStr(ts: number): string {\n const dt = new Date(1000 * ts);\n // const year = dt.getFullYear();\n // const mo = String(dt.getMonth() + 1).padStart(2, '0');\n // const day = String(dt.getDate()).padStart(2, '0');\n const hour = String(dt.getHours()).padStart(2, '0');\n const min = String(dt.getMinutes()).padStart(2, '0');\n const sec = String(dt.getSeconds()).padStart(2, '0');\n const ms = String(dt.getMilliseconds()).padStart(3, '0');\n // const s = `${year}-${mo}-${day} ${hour}:${min}:${sec}.${ms}`;\n const s = `${hour}:${min}:${sec}.${ms}`;\n return s;\n}\n\nfunction htmlEscape(text: string): string {\n return text.replaceAll('&', '&').replaceAll('<', '<').replaceAll('>', '>');\n}\n\nfunction parseLogLine(line: string): LogLine {\n let str = line.replaceAll('\\n', ' ').replaceAll('\\\\', '\\\\\\\\');\n const tracebackIndex = str.indexOf('Traceback');\n if (tracebackIndex !== -1) str = str.substring(0, tracebackIndex);\n const parsed = JSON.parse(str) as Partial;\n return {\n created: Number(parsed.created ?? Date.now()),\n level: String(parsed.level ?? 'INFO'),\n module: String(parsed.module ?? 'logMonitor'),\n facility: String(parsed.facility ?? 'ui'),\n msg: String(parsed.msg ?? ''),\n };\n}\n\nasync function clearErrors(): Promise {\n logWarnings = 0;\n logErrors = 0;\n log('clearErrors');\n}\n\nexport async function initClearErrorsButton() {\n const btnServerClear = document.getElementById('btn_console_log_server_clear');\n if (btnServerClear) {\n btnServerClear.onclick = async (evt) => {\n evt.preventDefault();\n evt.stopPropagation();\n clearErrors();\n };\n }\n}\n\nasync function logMonitor() {\n const addLogLine = (line: string): void => {\n if (!logMonitorEl) logMonitorEl = document.getElementById('logMonitorData');\n if (!logMonitorEl) return;\n try {\n const l = parseLogLine(line);\n const row = document.createElement('tr');\n // row.style = 'padding: 10px; margin: 0;';\n const level = ``;\n if (l.level === 'WARNING') logWarnings++;\n if (l.level === 'ERROR') logErrors++;\n const module = ``;\n const facilityText = l.facility.length > 20 ? `${l.facility.substring(0, 20)}...` : l.facility;\n const facility = l.facility !== 'sd' ? `` : '';\n row.innerHTML = `${level}${facility}${module}`;\n logMonitorEl.appendChild(row);\n } catch (err) {\n error('logMonitor', { error: String(err), line });\n }\n };\n\n const cleanupLog = (atBottom: boolean): void => {\n if (!logMonitorEl) return;\n while (logMonitorEl.childElementCount > 100 && logMonitorEl.firstElementChild) {\n logMonitorEl.removeChild(logMonitorEl.firstElementChild);\n }\n if (atBottom) logMonitorEl.scrollTop = logMonitorEl.scrollHeight;\n else if (logMonitorEl.parentElement) logMonitorEl.parentElement.style.cssText = 'border-bottom: 2px solid var(--highlight-color);';\n const elWarn = document.getElementById('logWarnings');\n const elErr = document.getElementById('logErrors');\n const modenUIBtn = document.getElementById('btn_console');\n if (elWarn) elWarn.innerText = String(logWarnings);\n if (elErr) elErr.innerText = String(logErrors);\n if (modenUIBtn) {\n modenUIBtn.setAttribute('error-count', logErrors > 0 ? String(logErrors) : '');\n modenUIBtn.style.backgroundColor = logErrors > 0 ? 'var(--color-error)' : '';\n modenUIBtn.title = `Log\\nErrors ${logErrors}\\nWarnings ${logWarnings}`;\n }\n };\n\n const txtGallery = document.getElementById('txt2img_gallery');\n if (txtGallery) txtGallery.style.height = window.opts.logmonitor_show ? '50vh' : '55vh';\n const imgGallery = document.getElementById('img2img_gallery');\n if (imgGallery) imgGallery.style.height = window.opts.logmonitor_show ? '50vh' : '55vh';\n\n if (!window.opts.logmonitor_show) {\n Array.from(document.getElementsByClassName('log-monitor')).forEach((el) => {\n if (el instanceof HTMLElement) el.style.display = 'none';\n });\n return;\n }\n\n if (logMonitorStatus) setTimeout(logMonitor, window.opts.logmonitor_refresh_period);\n else setTimeout(logMonitor, 10 * 1000); // on failure try to reconnect every 10sec\n\n logMonitorStatus = false;\n if (!logMonitorEl) {\n logMonitorEl = document.getElementById('logMonitorData');\n if (logMonitorEl) {\n logMonitorEl.addEventListener('scroll', () => {\n const atBottom = logMonitorEl.scrollHeight <= (logMonitorEl.scrollTop + logMonitorEl.clientHeight);\n if (atBottom && logMonitorEl.parentElement) logMonitorEl.parentElement.style.cssText = '';\n });\n }\n }\n if (!logMonitorEl) return;\n const atBottom = logMonitorEl.scrollHeight <= (logMonitorEl.scrollTop + logMonitorEl.clientHeight);\n\n try {\n const res = await authFetch(`${window.api}/log?clear=True`);\n if (res?.ok) {\n logMonitorStatus = true;\n const lines = (await res.json()) as string[];\n if (logMonitorEl && lines?.length > 0 && logMonitorEl.parentElement?.parentElement instanceof HTMLElement) {\n logMonitorEl.parentElement.parentElement.style.display = window.opts.logmonitor_show ? 'block' : 'none';\n }\n if (!logConnected) {\n logConnected = true;\n xhrPost(`${window.api}/log`, { debug: 'connected' });\n logErrors = 0; // reset error count on reconnect\n }\n for (const line of lines) addLogLine(line);\n } else {\n logConnected = false;\n logErrors++;\n if (res) addLogLine(`{ \"created\": ${Date.now()}, \"level\":\"ERROR\", \"module\":\"logMonitor\", \"facility\":\"ui\", \"msg\":\"Failed to fetch log: ${res?.status} ${res?.statusText}\" }`);\n else addLogLine(`{ \"created\": ${Date.now()}, \"level\":\"ERROR\", \"module\":\"logMonitor\", \"facility\":\"ui\", \"msg\":\"Server unreachable\" }`);\n }\n cleanupLog(atBottom);\n } catch {\n logConnected = false;\n logErrors++;\n addLogLine(`{ \"created\": ${Date.now()}, \"level\":\"ERROR\", \"module\":\"logMonitor\", \"facility\":\"ui\", \"msg\":\"Server unreachable\" }`);\n cleanupLog(atBottom);\n }\n}\n\nexport async function initLogMonitor() {\n let el = document.getElementById('logMonitorPlaceholder');\n const modernUi = Boolean(el);\n if (!el) el = document.getElementsByTagName('footer')[0];\n if (!el) return;\n const t0 = performance.now();\n el.classList.add('log-monitor');\n const uiDisabled = Array.isArray(window.opts.ui_disabled) ? window.opts.ui_disabled : [];\n if (uiDisabled.includes('logs')) return;\n if (modernUi) {\n el.style.overflow = 'auto';\n el.innerHTML = `\n
    ${l.level}${l.module}${facilityText}${dateToStr(l.created)}${htmlEscape(l.msg)}
    \n \n \n
    \n `;\n } else {\n el.innerHTML = `\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
    TimeLevelModuleMessageWarnings 0Errors 0
    \n `;\n }\n el.style.display = 'none';\n authFetch(`${window.api}/start?agent=${encodeURI(navigator.userAgent)}`);\n logMonitor();\n initClearErrorsButton();\n const t1 = performance.now();\n log('initLogMonitor', { show: window.opts.logmonitor_show, time: Math.round(t1 - t0) });\n timer('initLogMonitor', t1 - t0);\n}\n", "import { authFetch } from './authWrap';\nimport { gradioApp, onAfterUiUpdate, onOptionsChanged, executeCallbacks, optionsChangedCallbacks } from './script';\nimport { log, debug, error } from './logger';\nimport { getENActiveTab } from './extraNetworks';\nimport { registerDragDrop, toggleCompact, setTheme, setFontSize, updateInput } from './ui';\nimport { timer } from './timers';\n\nlet settingsInitialized = false;\nlet opts_metadata = {};\nconst opts_tabs = {};\n\nfunction getSettingsTabs() {\n let nodes = gradioApp().querySelectorAll('#tab_settings .tabitem');\n if (!nodes || nodes.length === 0) nodes = gradioApp().querySelectorAll('.tab-content .tabitem');\n return nodes;\n}\n\nconst monitoredOpts: Record[] = [\n { sd_model_checkpoint: null },\n { sd_backend: () => gradioApp().getElementById('refresh_sd_model_checkpoint')?.click() },\n];\n\nexport function monitorOption(option, callback) {\n monitoredOpts.push({ [option]: callback });\n}\n\nconst AppyOpts = [ // monitored opts\n { compact_view: (val, old) => toggleCompact(val, old) },\n { gradio_theme: (val, old) => setTheme(val, old) },\n { font_size: (val, old) => setFontSize(val, old) },\n];\n\nasync function updateOpts(json_string) {\n const t0 = performance.now();\n const settings_data = JSON.parse(json_string);\n const new_opts = settings_data.values;\n opts_metadata = settings_data.metadata;\n\n const t1 = performance.now();\n for (const op of monitoredOpts) {\n const [key, callback] = Object.entries(op)[0];\n if (Object.hasOwn(opts, key) && opts[key] !== new_opts[key]) {\n log('updateOpt', key, opts[key], new_opts[key]);\n if (callback) callback(new_opts[key], opts[key]);\n }\n }\n\n for (const op of AppyOpts) {\n const [key, callback] = Object.entries(op)[0];\n if (callback) {\n const t3 = performance.now();\n callback(new_opts[key], opts[key]);\n const t4 = performance.now();\n if (t4 - t3 > 100) debug('AppyOptSlow', key, `time=${Math.round(t4 - t3)}`);\n }\n }\n\n window.opts = new_opts;\n Object.entries(opts_metadata as Record).forEach(([opt, meta]: [string, any]) => {\n if (!opts_tabs[meta.tab_name]) opts_tabs[meta.tab_name] = {};\n if (!opts_tabs[meta.tab_name].unsaved_keys) opts_tabs[meta.tab_name].unsaved_keys = new Set();\n if (!opts_tabs[meta.tab_name].saved_keys) opts_tabs[meta.tab_name].saved_keys = new Set();\n if (!meta.is_stored) opts_tabs[meta.tab_name].unsaved_keys.add(opt);\n else opts_tabs[meta.tab_name].saved_keys.add(opt);\n });\n const t2 = performance.now();\n log('updateOpts', { settings: Object.keys(new_opts).length, callbacks: Math.round(t2 - t1), apply: Math.round(t1 - t0) });\n timer('updateOpts', t2 - t0);\n}\n\nfunction showAllSettings() {\n // Try to ensure that the show all settings tab is opened by clicking on its tab button\n // const tab_dirty_indicator = gradioApp().getElementById('modification_indicator_show_all_pages');\n // if (tab_dirty_indicator && tab_dirty_indicator.nextSibling) tab_dirty_indicator.nextSibling.click();\n getSettingsTabs().forEach((elem) => {\n if (elem.id === 'settings_tab_licenses' || elem.id === 'settings_show_all_pages') return;\n elem.style.display = 'block';\n });\n}\n\nfunction markIfModified(setting_name, value) {\n if (!opts_metadata[setting_name]) return;\n const elem = gradioApp().getElementById(`modification_indicator_${setting_name}`);\n if (!elem) return;\n const previous_value = JSON.stringify(opts[setting_name]);\n const current_value = JSON.stringify(value);\n const changed_value = previous_value !== current_value;\n if (changed_value) elem.title = `click to revert to previous value: ${previous_value}`;\n const { is_stored } = opts_metadata[setting_name];\n if (is_stored) elem.title = 'custom value';\n elem.disabled = !changed_value && !is_stored;\n elem.classList.toggle('changed', changed_value);\n elem.classList.toggle('saved', is_stored);\n\n const { tab_name } = opts_metadata[setting_name];\n if (!opts_tabs[tab_name].changed) opts_tabs[tab_name].changed = new Set();\n const changed_items = opts_tabs[tab_name].changed;\n if (changed_value) changed_items.add(setting_name);\n else changed_items.delete(setting_name);\n const unsaved = opts_tabs[tab_name].unsaved_keys;\n const saved = opts_tabs[tab_name].saved_keys;\n\n // Set the indicator on the tab nav element\n const tab_nav_indicator = gradioApp().getElementById(`modification_indicator_${tab_name}`);\n tab_nav_indicator.disabled = (changed_items.size === 0) && (unsaved.size === 0);\n tab_nav_indicator.title = '';\n tab_nav_indicator.classList.toggle('changed', changed_items.size > 0);\n tab_nav_indicator.classList.toggle('saved', saved.size > 0);\n if (changed_items.size > 0) tab_nav_indicator.title += `click to reset ${changed_items.size} unapplied changes in this tab\\n`;\n if (saved.size > 0) tab_nav_indicator.title += `${saved.size} custom values\\n${unsaved.size} default values`;\n // TODO why is scroll happening on every change if all pages are visible?\n // elem.scrollIntoView({ behavior: 'smooth', block: 'center' });\n}\nwindow.markIfModified = markIfModified;\n\nfunction updateAllOpts() {\n if (Object.keys(opts).length !== 0) return false;\n const json_elem = gradioApp().getElementById('settings_json');\n log('updateAllOpts', !!json_elem);\n if (!json_elem) return false;\n json_elem.parentElement.style.display = 'none';\n const textarea = json_elem.querySelector('textarea');\n const jsdata = textarea.value;\n updateOpts(jsdata);\n return true;\n}\n\nasync function onAfterUiUpdateCallback() {\n if (!updateAllOpts()) return;\n const json_elem = gradioApp().getElementById('settings_json');\n const textarea = json_elem.querySelector('textarea');\n executeCallbacks(optionsChangedCallbacks);\n registerDragDrop();\n\n Object.defineProperty(textarea, 'value', {\n set(newValue) {\n const valueProp = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value');\n const oldValue = valueProp.get.call(textarea);\n valueProp.set.call(textarea, newValue);\n if (oldValue !== newValue) updateOpts(textarea.value);\n executeCallbacks(optionsChangedCallbacks);\n },\n get() {\n const valueProp = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value');\n return valueProp.get.call(textarea);\n },\n });\n\n const settingsSearch = gradioApp().querySelectorAll('#settings_search > label > textarea')[0];\n let settingsTimer: ReturnType | undefined;\n let settingSearchValue = '';\n\n function doSettingsSearch() {\n if (settingSearchValue === settingsSearch.value.trim().toLowerCase()) return;\n showAllSettings();\n const value = settingsSearch.value.trim().toLowerCase();\n log('doSettingsSearch', value);\n settingSearchValue = value;\n getSettingsTabs().forEach((section) => {\n section.querySelectorAll('.dirtyable').forEach((setting) => {\n const visible = setting.innerText.toLowerCase().includes(value) || setting.id.toLowerCase().includes(value);\n const parent = setting.closest('.settings_section');\n if (!visible) parent.style.display = 'none';\n else parent.style.removeProperty('display');\n });\n });\n }\n\n settingsSearch.oninput = (e) => {\n if (settingsTimer) clearTimeout(settingsTimer);\n settingsTimer = setTimeout(doSettingsSearch, 250);\n };\n settingsSearch.onkeypress = (e) => {\n if (e.key === 'Enter') {\n if (settingsTimer) clearTimeout(settingsTimer);\n doSettingsSearch();\n }\n };\n}\n\nonAfterUiUpdate(onAfterUiUpdateCallback);\n\nasync function onOptionsChangedCallback() {\n const setting_elems = gradioApp().querySelectorAll('#settings [id^=\"setting_\"]');\n setting_elems.forEach((elem) => {\n const setting_name = elem.id.replace('setting_', '');\n markIfModified(setting_name, opts[setting_name]);\n });\n}\n\nonOptionsChanged(onOptionsChangedCallback);\n\nexport async function initModels() {\n const warn = () => `\n

    No models available

    \n - Select a model from reference list to download or
    \n - Set model path to a folder containing your models
    \n Current model path: ${opts.ckpt_dir}
    \n `;\n const el = gradioApp().getElementById('main_info');\n const en = gradioApp().getElementById('txt2img_extra_networks');\n if (!el || !en) return;\n const req = await authFetch(`${window.api}/sd-models`);\n const res = req.ok ? await req.json() : [];\n log('initModels', res.length);\n const ready = () => `\n

    Ready

    \n ${res.length} models available
    \n `;\n el.innerHTML = res.length > 0 ? ready() : warn();\n el.style.display = 'block';\n setTimeout(() => { el.style.display = 'none'; }, res.length === 0 ? 30000 : 1500);\n if (res.length === 0) {\n if (en.classList.contains('hide')) gradioApp().getElementById('txt2img_extra_networks_btn').click();\n const repeat = setInterval(() => {\n const buttons = Array.from(gradioApp().querySelectorAll('#txt2img_model_subdirs > button')) || [];\n const reference = buttons.find((b) => (b.innerText === 'Reference') || (b.innerText === 'Distilled') || (b.innerText === 'Community') || (b.innerText === 'Quantized') || (b.innerText === 'Cloud'));\n if (reference) {\n clearInterval(repeat);\n reference.click();\n log('enReferenceSelect');\n }\n }, 100);\n }\n}\n\nexport async function initSettings() {\n if (settingsInitialized) return;\n const t0 = performance.now();\n settingsInitialized = true;\n const tabNavElements = gradioApp().querySelector('#settings > .tab-nav');\n if (!tabNavElements) {\n error('initSettings', 'No tab nav elements found');\n return;\n }\n const tabNavButtons = gradioApp().querySelectorAll('#settings > .tab-nav > button');\n const tabElements = gradioApp().querySelectorAll('#settings > div:not(.tab-nav)');\n const observer = new MutationObserver((mutations) => {\n const showAllPages = gradioApp().getElementById('settings_show_all_pages');\n if (showAllPages.style.display === 'none') return;\n const mutation = (mut) => mut.type === 'attributes' && mut.attributeName === 'style';\n if (mutations.some(mutation)) showAllSettings();\n });\n const tabContentWrapper = document.createElement('div');\n tabContentWrapper.className = 'tab-content';\n tabNavElements.parentElement.insertBefore(tabContentWrapper, tabNavElements.nextSibling);\n tabElements.forEach((elem, index) => {\n const tabName = elem.id.replace('settings_section_tab_', '');\n const indicator = gradioApp().getElementById(`modification_indicator_${tabName}`);\n if (indicator) {\n tabNavElements.insertBefore(document.createElement('br'), tabNavButtons[index]);\n tabNavElements.insertBefore(indicator, tabNavButtons[index]);\n }\n tabContentWrapper.appendChild(elem);\n observer.observe(elem, { attributes: true, attributeFilter: ['style'] });\n });\n const t1 = performance.now();\n log('initSettings', Math.round(t1 - t0));\n timer('initSettings', t1 - t0);\n}\n", "import { debug, log } from './logger';\nimport { authFetch } from './authWrap';\nimport { monitorOption } from './settings';\n\ninterface VersionInfo {\n updated?: string;\n commit?: string;\n branch?: string;\n model?: string;\n}\n\nlet monitorActive = false;\n\nexport class ConnectionMonitorState {\n static ws: WebSocket | undefined;\n static url = '';\n static delay = 1000;\n static element: HTMLElement | undefined;\n static version = '';\n static commit = '';\n static branch = '';\n static model = '';\n static startup: Date = new Date();\n static online = false;\n static ts: Date = new Date();\n\n static getModel(): string {\n const cp = window.opts?.sd_model_checkpoint || '';\n return cp ? this.trimModelName(cp) : 'unknown model';\n }\n\n static trimModelName(name: string): string {\n return name.replace(/\\s*\\[.*\\]\\s*$/, '').split(/[\\\\/]/).pop().trim() || 'unknown model';\n }\n\n static setData({ online, data }: { online: boolean; data: VersionInfo }) {\n if (online !== this.online) {\n this.online = online;\n this.ts = new Date();\n debug('monitorState', { online: ConnectionMonitorState.online, ts: ConnectionMonitorState.ts });\n }\n if (data?.updated) this.version = data.updated;\n if (data?.commit) this.commit = data.commit;\n if (data?.branch) this.branch = data.branch;\n if (data?.model) this.model = this.trimModelName(data.model);\n }\n\n static toHTML(): string {\n if (!this.model) this.model = this.getModel();\n return `\n Version: ${this.version}
    \n Commit: ${this.commit}
    \n Branch: ${this.branch}
    \n Status: ${this.online ? 'online' : 'offline'}
    \n Model: ${this.model}
    \n Since: ${this.startup.toLocaleString()}
    \n `;\n }\n\n static updateState() {\n if (!this.element) {\n const el = document.getElementById('logo_nav');\n if (el) this.element = el;\n else return;\n }\n this.element.dataset.hint = this.toHTML();\n this.element.style.backgroundColor = this.online ? 'var(--sd-main-accent-color)' : 'var(--color-error)';\n }\n}\n\nasync function updateIndicator(online: boolean, data: VersionInfo = {}, msg?: string): Promise {\n ConnectionMonitorState.setData({ online, data });\n ConnectionMonitorState.updateState();\n if (msg) log('monitorConnection:', { online, data, msg });\n}\n\nasync function wsMonitorLoop() {\n const delayed = Date.now() - ConnectionMonitorState.ts.getTime();\n if ((delayed > 60 * 60) && (ConnectionMonitorState.delay < 10) && !ConnectionMonitorState.online) ConnectionMonitorState.delay = 10000;\n else if ((delayed > 5 * 60) && (ConnectionMonitorState.delay < 5) && !ConnectionMonitorState.online) ConnectionMonitorState.delay = 5000;\n else ConnectionMonitorState.delay = 2000;\n try {\n ConnectionMonitorState.ws = new WebSocket(`${ConnectionMonitorState.url}/queue/join`);\n ConnectionMonitorState.ws.onopen = () => {};\n ConnectionMonitorState.ws.onmessage = () => updateIndicator(true);\n ConnectionMonitorState.ws.onclose = () => setTimeout(wsMonitorLoop, ConnectionMonitorState.delay); // main re-check loop\n ConnectionMonitorState.ws.onerror = (e: Event) => updateIndicator(false, {}, String((e as ErrorEvent).message || 'unknown error')); // actual error\n } catch (e) {\n updateIndicator(false, {}, String((e as Error).message || e));\n // eslint-disable-next-line @typescript-eslint/no-use-before-define\n setTimeout(monitorConnection, ConnectionMonitorState.delay);\n }\n}\n\nexport async function monitorConnection() {\n if (!monitorActive) { // start monitor loop only once on startup\n monitorActive = true;\n monitorOption('sd_model_checkpoint', (newVal) => { // runs before opt actually changes\n ConnectionMonitorState.model = newVal;\n ConnectionMonitorState.updateState();\n });\n }\n ConnectionMonitorState.startup = new Date();\n\n let data: VersionInfo = {};\n try {\n const res = await authFetch(`${window.api}/version`);\n if (!res) throw new Error('No response');\n data = await res.json();\n log('monitorConnection:', { data });\n ConnectionMonitorState.startup = new Date();\n ConnectionMonitorState.url = res.url.split('/sdapi')[0].replace('https:', 'wss:').replace('http:', 'ws:'); // update global url as ws need fqdn\n updateIndicator(true, data);\n wsMonitorLoop();\n } catch {\n updateIndicator(false, data);\n setTimeout(monitorConnection, ConnectionMonitorState.delay);\n }\n}\n", "// Stable Diffusion WebUI - Bracket checker\n// By Hingashi no Florin/Bwin4L & @akx\n// Counts open and closed brackets (round, square, curly) in the prompt and negative prompt text boxes in the txt2img and img2img tabs.\n// If there's a mismatch, the keyword counter turns red and if you hover on it, a tooltip tells you what's wrong.\n\nimport { gradioApp } from './script';\nimport { log } from './logger';\nimport { timer } from './timers';\n\nfunction checkBrackets(textArea: HTMLTextAreaElement, counterElt: HTMLElement): void {\n const counts: Record = {};\n const errors: string[] = [];\n\n function checkPair(open: string, close: string, kind: string): void {\n if (counts[open] !== counts[close]) errors.push(`${open}...${close} - Detected ${counts[open] || 0} opening and ${counts[close] || 0} closing ${kind}.`);\n }\n\n (textArea.value.match(/[(){}[\\]]/g) || []).forEach((bracket) => { counts[bracket] = (counts[bracket] || 0) + 1; });\n checkPair('(', ')', 'round brackets');\n checkPair('[', ']', 'square brackets');\n checkPair('{', '}', 'curly brackets');\n counterElt.title = errors.join('\\n');\n counterElt.classList.toggle('error', errors.length !== 0);\n}\n\nfunction setupBracketChecking(idPrompt: string, idCounter: string): void {\n const textarea = gradioApp().querySelector(`#${idPrompt} > label > textarea`);\n const counter = gradioApp().getElementById(idCounter);\n if (!(textarea instanceof HTMLTextAreaElement) || !counter) return;\n textarea.addEventListener('input', () => checkBrackets(textarea, counter));\n}\n\nexport async function initPromptChecker() {\n const t0 = performance.now();\n setupBracketChecking('txt2img_prompt', 'txt2img_token_counter');\n setupBracketChecking('txt2img_neg_prompt', 'txt2img_negative_token_counter');\n setupBracketChecking('img2img_prompt', 'img2img_token_counter');\n setupBracketChecking('img2img_neg_prompt', 'img2img_negative_token_counter');\n setupBracketChecking('control_prompt', 'control_token_counter');\n setupBracketChecking('control_neg_prompt', 'control_negative_token_counter');\n setupBracketChecking('video_prompt', 'video_token_counter');\n setupBracketChecking('video_neg_prompt', 'video_negative_token_counter');\n const t1 = performance.now();\n log('initPromptChecker', Math.round(t1 - t0));\n timer('initPromptChecker', t1 - t0);\n}\n", "// @ts-nocheck\n\n// SHA-256 (+ HMAC and PBKDF2) for JavaScript.\n//\n// Written in 2014-2016 by Dmitry Chestnykh.\n// Public domain, no warranty.\n//\n// Functions (accept and return Uint8Arrays):\n//\n// sha256(message) -> hash\n// sha256.hmac(key, message) -> mac\n// sha256.pbkdf2(password, salt, rounds, dkLen) -> dk\n//\n// Classes:\n//\n// new sha256.Hash()\n// new sha256.HMAC(key)\n//\n\n\nconst digestLength = 32;\nconst blockSize = 64;\n\n// SHA-256 constants\n\nconst K = new Uint32Array([\n 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,\n 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,\n 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,\n 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,\n 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,\n 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,\n 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,\n 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,\n 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,\n 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,\n]);\nfunction hashBlocks(w, v, p, pos, len) {\n let a; let b; let c; let d; let e; let f; let g; let h; let u; let i; let j; let t1; let\n t2;\n while (len >= 64) {\n a = v[0];\n b = v[1];\n c = v[2];\n d = v[3];\n e = v[4];\n f = v[5];\n g = v[6];\n h = v[7];\n for (i = 0; i < 16; i++) {\n j = pos + i * 4;\n w[i] = (((p[j] & 0xff) << 24) | ((p[j + 1] & 0xff) << 16)\n | ((p[j + 2] & 0xff) << 8) | (p[j + 3] & 0xff));\n }\n for (i = 16; i < 64; i++) {\n u = w[i - 2];\n t1 = (u >>> 17 | u << (32 - 17)) ^ (u >>> 19 | u << (32 - 19)) ^ (u >>> 10);\n u = w[i - 15];\n t2 = (u >>> 7 | u << (32 - 7)) ^ (u >>> 18 | u << (32 - 18)) ^ (u >>> 3);\n w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);\n }\n for (i = 0; i < 64; i++) {\n t1 = (((((e >>> 6 | e << (32 - 6)) ^ (e >>> 11 | e << (32 - 11))\n ^ (e >>> 25 | e << (32 - 25))) + ((e & f) ^ (~e & g))) | 0)\n + ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;\n t2 = (((a >>> 2 | a << (32 - 2)) ^ (a >>> 13 | a << (32 - 13))\n ^ (a >>> 22 | a << (32 - 22))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;\n h = g;\n g = f;\n f = e;\n e = (d + t1) | 0;\n d = c;\n c = b;\n b = a;\n a = (t1 + t2) | 0;\n }\n v[0] += a;\n v[1] += b;\n v[2] += c;\n v[3] += d;\n v[4] += e;\n v[5] += f;\n v[6] += g;\n v[7] += h;\n pos += 64;\n len -= 64;\n }\n return pos;\n}\n// Hash implements SHA256 hash algorithm.\nconst Hash = /** @class */ (function () {\n function Hash() {\n this.digestLength = digestLength;\n this.blockSize = blockSize;\n // Note: Int32Array is used instead of Uint32Array for performance reasons.\n this.state = new Int32Array(8); // hash state\n this.temp = new Int32Array(64); // temporary state\n this.buffer = new Uint8Array(128); // buffer for data to hash\n this.bufferLength = 0; // number of bytes in buffer\n this.bytesHashed = 0; // number of total bytes hashed\n this.finished = false; // indicates whether the hash was finalized\n this.reset();\n }\n // Resets hash state making it possible\n // to reuse this instance to hash other data.\n Hash.prototype.reset = function () {\n this.state[0] = 0x6a09e667;\n this.state[1] = 0xbb67ae85;\n this.state[2] = 0x3c6ef372;\n this.state[3] = 0xa54ff53a;\n this.state[4] = 0x510e527f;\n this.state[5] = 0x9b05688c;\n this.state[6] = 0x1f83d9ab;\n this.state[7] = 0x5be0cd19;\n this.bufferLength = 0;\n this.bytesHashed = 0;\n this.finished = false;\n return this;\n };\n // Cleans internal buffers and re-initializes hash state.\n Hash.prototype.clean = function () {\n for (var i = 0; i < this.buffer.length; i++) {\n this.buffer[i] = 0;\n }\n for (var i = 0; i < this.temp.length; i++) {\n this.temp[i] = 0;\n }\n this.reset();\n };\n // Updates hash state with the given data.\n //\n // Optionally, length of the data can be specified to hash\n // fewer bytes than data.length.\n //\n // Throws error when trying to update already finalized hash:\n // instance must be reset to use it again.\n Hash.prototype.update = function (data, dataLength) {\n if (dataLength === void 0) { dataLength = data.length; }\n if (this.finished) {\n throw new Error(\"SHA256: can't update because hash was finished.\");\n }\n let dataPos = 0;\n this.bytesHashed += dataLength;\n if (this.bufferLength > 0) {\n while (this.bufferLength < 64 && dataLength > 0) {\n this.buffer[this.bufferLength++] = data[dataPos++];\n dataLength--;\n }\n if (this.bufferLength === 64) {\n hashBlocks(this.temp, this.state, this.buffer, 0, 64);\n this.bufferLength = 0;\n }\n }\n if (dataLength >= 64) {\n dataPos = hashBlocks(this.temp, this.state, data, dataPos, dataLength);\n dataLength %= 64;\n }\n while (dataLength > 0) {\n this.buffer[this.bufferLength++] = data[dataPos++];\n dataLength--;\n }\n return this;\n };\n // Finalizes hash state and puts hash into out.\n //\n // If hash was already finalized, puts the same value.\n Hash.prototype.finish = function (out) {\n if (!this.finished) {\n const bytesHashed = this.bytesHashed;\n const left = this.bufferLength;\n const bitLenHi = (bytesHashed / 0x20000000) | 0;\n const bitLenLo = bytesHashed << 3;\n const padLength = (bytesHashed % 64 < 56) ? 64 : 128;\n this.buffer[left] = 0x80;\n for (let i = left + 1; i < padLength - 8; i++) {\n this.buffer[i] = 0;\n }\n this.buffer[padLength - 8] = (bitLenHi >>> 24) & 0xff;\n this.buffer[padLength - 7] = (bitLenHi >>> 16) & 0xff;\n this.buffer[padLength - 6] = (bitLenHi >>> 8) & 0xff;\n this.buffer[padLength - 5] = (bitLenHi >>> 0) & 0xff;\n this.buffer[padLength - 4] = (bitLenLo >>> 24) & 0xff;\n this.buffer[padLength - 3] = (bitLenLo >>> 16) & 0xff;\n this.buffer[padLength - 2] = (bitLenLo >>> 8) & 0xff;\n this.buffer[padLength - 1] = (bitLenLo >>> 0) & 0xff;\n hashBlocks(this.temp, this.state, this.buffer, 0, padLength);\n this.finished = true;\n }\n for (let i = 0; i < 8; i++) {\n out[i * 4 + 0] = (this.state[i] >>> 24) & 0xff;\n out[i * 4 + 1] = (this.state[i] >>> 16) & 0xff;\n out[i * 4 + 2] = (this.state[i] >>> 8) & 0xff;\n out[i * 4 + 3] = (this.state[i] >>> 0) & 0xff;\n }\n return this;\n };\n // Returns the final hash digest.\n Hash.prototype.digest = function () {\n const out = new Uint8Array(this.digestLength);\n this.finish(out);\n return out;\n };\n // Internal function for use in HMAC for optimization.\n Hash.prototype._saveState = function (out) {\n for (let i = 0; i < this.state.length; i++) {\n out[i] = this.state[i];\n }\n };\n // Internal function for use in HMAC for optimization.\n Hash.prototype._restoreState = function (from, bytesHashed) {\n for (let i = 0; i < this.state.length; i++) {\n this.state[i] = from[i];\n }\n this.bytesHashed = bytesHashed;\n this.finished = false;\n this.bufferLength = 0;\n };\n return Hash;\n}());\nwindow.Hash = Hash;\n// HMAC implements HMAC-SHA256 message authentication algorithm.\nconst HMAC = /** @class */ (function () {\n function HMAC(key) {\n this.inner = new Hash();\n this.outer = new Hash();\n this.blockSize = this.inner.blockSize;\n this.digestLength = this.inner.digestLength;\n const pad = new Uint8Array(this.blockSize);\n if (key.length > this.blockSize) {\n (new Hash()).update(key).finish(pad).clean();\n } else {\n for (let i = 0; i < key.length; i++) {\n pad[i] = key[i];\n }\n }\n for (let i = 0; i < pad.length; i++) {\n pad[i] ^= 0x36;\n }\n this.inner.update(pad);\n for (let i = 0; i < pad.length; i++) {\n pad[i] ^= 0x36 ^ 0x5c;\n }\n this.outer.update(pad);\n this.istate = new Uint32Array(8);\n this.ostate = new Uint32Array(8);\n this.inner._saveState(this.istate);\n this.outer._saveState(this.ostate);\n for (let i = 0; i < pad.length; i++) {\n pad[i] = 0;\n }\n }\n // Returns HMAC state to the state initialized with key\n // to make it possible to run HMAC over the other data with the same\n // key without creating a new instance.\n HMAC.prototype.reset = function () {\n this.inner._restoreState(this.istate, this.inner.blockSize);\n this.outer._restoreState(this.ostate, this.outer.blockSize);\n return this;\n };\n // Cleans HMAC state.\n HMAC.prototype.clean = function () {\n for (let i = 0; i < this.istate.length; i++) {\n this.ostate[i] = this.istate[i] = 0;\n }\n this.inner.clean();\n this.outer.clean();\n };\n // Updates state with provided data.\n HMAC.prototype.update = function (data) {\n this.inner.update(data);\n return this;\n };\n // Finalizes HMAC and puts the result in out.\n HMAC.prototype.finish = function (out) {\n if (this.outer.finished) {\n this.outer.finish(out);\n } else {\n this.inner.finish(out);\n this.outer.update(out, this.digestLength).finish(out);\n }\n return this;\n };\n // Returns message authentication code.\n HMAC.prototype.digest = function () {\n const out = new Uint8Array(this.digestLength);\n this.finish(out);\n return out;\n };\n return HMAC;\n}());\nwindow.HMAC = HMAC;\n// Returns SHA256 hash of data.\nfunction hash(data) {\n const h = (new Hash()).update(data);\n const digest = h.digest();\n h.clean();\n return digest;\n}\nwindow.hash = hash;\n// Function hash is both available as module.hash and as default export.\n// Returns HMAC-SHA256 of data under the key.\nfunction hmac(key, data) {\n const h = (new HMAC(key)).update(data);\n const digest = h.digest();\n h.clean();\n return digest;\n}\nwindow.hmac = hmac;\n// Fills hkdf buffer like this:\n// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01)\nfunction fillBuffer(buffer, hmac, info, counter) {\n // Counter is a byte value: check if it overflowed.\n const num = counter[0];\n if (num === 0) {\n throw new Error('hkdf: cannot expand more');\n }\n // Prepare HMAC instance for new data with old key.\n hmac.reset();\n // Hash in previous output if it was generated\n // (i.e. counter is greater than 1).\n if (num > 1) {\n hmac.update(buffer);\n }\n // Hash in info if it exists.\n if (info) {\n hmac.update(info);\n }\n // Hash in the counter.\n hmac.update(counter);\n // Output result to buffer and clean HMAC instance.\n hmac.finish(buffer);\n // Increment counter inside typed array, this works properly.\n counter[0]++;\n}\nconst hkdfSalt = new Uint8Array(digestLength); // Filled with zeroes.\nfunction hkdf(key, salt, info, length) {\n if (salt === void 0) { salt = hkdfSalt; }\n if (length === void 0) { length = 32; }\n const counter = new Uint8Array([1]);\n // HKDF-Extract uses salt as HMAC key, and key as data.\n const okm = hmac(salt, key);\n // Initialize HMAC for expanding with extracted key.\n // Ensure no collisions with `hmac` function.\n const hmac_ = new HMAC(okm);\n // Allocate buffer.\n const buffer = new Uint8Array(hmac_.digestLength);\n let bufpos = buffer.length;\n const out = new Uint8Array(length);\n for (let i = 0; i < length; i++) {\n if (bufpos === buffer.length) {\n fillBuffer(buffer, hmac_, info, counter);\n bufpos = 0;\n }\n out[i] = buffer[bufpos++];\n }\n hmac_.clean();\n buffer.fill(0);\n counter.fill(0);\n return out;\n}\nwindow.hkdf = hkdf;\n// Derives a key from password and salt using PBKDF2-HMAC-SHA256\n// with the given number of iterations.\n//\n// The number of bytes returned is equal to dkLen.\n//\n// (For better security, avoid dkLen greater than hash length - 32 bytes).\nfunction pbkdf2(password, salt, iterations, dkLen) {\n const prf = new HMAC(password);\n const len = prf.digestLength;\n const ctr = new Uint8Array(4);\n const t = new Uint8Array(len);\n const u = new Uint8Array(len);\n const dk = new Uint8Array(dkLen);\n for (var i = 0; i * len < dkLen; i++) {\n const c = i + 1;\n ctr[0] = (c >>> 24) & 0xff;\n ctr[1] = (c >>> 16) & 0xff;\n ctr[2] = (c >>> 8) & 0xff;\n ctr[3] = (c >>> 0) & 0xff;\n prf.reset();\n prf.update(salt);\n prf.update(ctr);\n prf.finish(u);\n for (var j = 0; j < len; j++) {\n t[j] = u[j];\n }\n for (var j = 2; j <= iterations; j++) {\n prf.reset();\n prf.update(u).finish(u);\n for (let k = 0; k < len; k++) {\n t[k] ^= u[k];\n }\n }\n for (var j = 0; j < len && i * len + j < dkLen; j++) {\n dk[i * len + j] = t[j];\n }\n }\n for (var i = 0; i < len; i++) {\n t[i] = u[i] = 0;\n }\n for (var i = 0; i < 4; i++) {\n ctr[i] = 0;\n }\n prf.clean();\n return dk;\n}\nwindow.pbkdf2 = pbkdf2;\n", "/* eslint-disable max-classes-per-file, @typescript-eslint/no-use-before-define */\nimport './js/sha256';\nimport { log, debug, error } from './logger';\nimport { authFetch } from './authWrap';\nimport { gradioApp, onAfterUiUpdate } from './script';\nimport { timer } from './timers';\nimport { monitorOption } from './settings';\n\nimport {\n idbAdd,\n idbCount,\n idbFolderCleanup,\n idbClearAll,\n idbGet,\n idbKeys,\n idbIsReady,\n} from './indexdb';\n\nlet ws;\nlet url;\nlet currentSize = 0;\nlet currentSort = 'none';\nlet currentName = '';\nlet currentImage = null;\nlet currentTitle = '';\nlet currentGalleryFolder = null;\nlet pruneImagesTimer;\nlet outstanding = 0;\nlet gallerySelection = { files: [], index: -1 };\nlet maintenanceController = new AbortController();\nconst maxFetchRequests = 32;\nconst fragmentSize = 100;\nconst minCleanupCount = 1000;\nconst minCleanupTime = 1000 * 60 * 60; // 1 hour\nconst folderStylesheet = new CSSStyleSheet();\nconst fileStylesheet = new CSSStyleSheet();\n// Store separator states for the session\nconst separatorStates = new Map();\nconst el = {\n folders: undefined,\n files: undefined,\n search: undefined,\n status: undefined,\n btnSend: undefined,\n overlay: undefined,\n size: undefined,\n};\nconst cleanupTimers = {};\nconst maintenanceTimers = {};\nconst fetchQueue = [];\nconst icons = {\n Time: String.fromCodePoint(9201),\n Folder: String.fromCodePoint(128448), // or 128449;\n Sort: String.fromCodePoint(8645),\n Images: String.fromCodePoint(128461),\n};\n\nconst SUPPORTED_EXTENSIONS = ['jpg', 'jpeg', 'png', 'webp', 'tiff', 'jp2', 'jxl', 'gif', 'mp4', 'mkv', 'avi', 'mjpeg', 'mpg', 'avr'];\n\nconst gallerySorter = {\n nameA: { name: 'Name Ascending', func: (a, b) => a.name.localeCompare(b.name) },\n nameD: { name: 'Name Descending', func: (b, a) => a.name.localeCompare(b.name) },\n sizeD: { name: 'Size Ascending', func: (a, b) => a.size - b.size },\n sizeA: { name: 'Size Descending', func: (b, a) => a.size - b.size },\n resD: { name: 'Resolution Ascending', func: (a, b) => a.width * a.height - b.width * b.height },\n resA: { name: 'Resolution Descending', func: (b, a) => a.width * a.height - b.width * b.height },\n modD: { name: 'Modified Ascending', func: (a, b) => a.mtime - b.mtime },\n modA: { name: 'Modified Descending', func: (b, a) => a.mtime - b.mtime },\n none: { name: 'None', func: undefined },\n};\nconst folderSorter = {\n nameA: { name: 'Name Ascending', func: (a, b) => a.name.localeCompare(b.name) },\n nameD: { name: 'Name Descending', func: (b, a) => a.name.localeCompare(b.name) },\n sizeD: { name: 'Size Ascending', func: (a, b) => a.size - b.size },\n sizeA: { name: 'Size Descending', func: (b, a) => a.size - b.size },\n resD: { name: 'Resolution Ascending', func: (a, b) => a.width * a.height - b.width * b.height },\n resA: { name: 'Resolution Descending', func: (b, a) => a.width * a.height - b.width * b.height },\n modD: { name: 'Modified Ascending', func: (a, b) => a.mtime - b.mtime },\n modA: { name: 'Modified Descending', func: (b, a) => a.mtime - b.mtime },\n none: { name: 'None', func: undefined },\n};\n\nlet sortMode = gallerySorter.none;\n\nasync function getHash(str) {\n let hex = '';\n const strBuf = new TextEncoder().encode(str);\n let hashBuf;\n if (crypto?.subtle?.digest) {\n hashBuf = await crypto.subtle.digest('SHA-256', strBuf);\n } else {\n const hashResult: any = hash(strBuf);\n hashBuf = hashResult.buffer; // from sha256.js\n }\n const view = new DataView(hashBuf);\n for (let i = 0; i < hashBuf.byteLength; i += 4) hex += (`00000000${view.getUint32(i).toString(16)}`).slice(-8);\n return hex;\n}\n\nfunction getVisibleGalleryFiles() {\n if (!el.files) return [];\n return Array.from(el.files.children).filter((node) => node.name && node.offsetParent);\n}\n\nfunction updateGallerySelectionClasses(files = gallerySelection.files, index = gallerySelection.index) {\n files.forEach((file, i) => {\n file.classList.toggle('gallery-file-selected', i === index);\n });\n}\n\nfunction refreshGallerySelection() {\n updateGallerySelectionClasses(gallerySelection.files, -1);\n const files = getVisibleGalleryFiles();\n const index = files.findIndex((file) => file.src === currentImage);\n gallerySelection = { files, index };\n updateGallerySelectionClasses(files, index);\n}\n\nfunction resetGallerySelection() {\n updateGallerySelectionClasses(gallerySelection.files, -1);\n gallerySelection = { files: [], index: -1 };\n currentImage = null;\n currentName = '';\n currentTitle = '';\n}\n\nfunction applyGallerySelection(index, { send = true } = {}) {\n if (!gallerySelection.files.length) refreshGallerySelection();\n const { files } = gallerySelection;\n if (!files.length) return;\n if (!Number.isInteger(index) || index < 0 || index >= files.length) {\n log('gallery selection index out of range', index, files.length);\n resetGallerySelection();\n return;\n }\n gallerySelection.index = index;\n currentImage = files[index].src;\n currentName = files[index].name;\n currentTitle = files[index].title;\n updateGallerySelectionClasses(files, index);\n if (send && el.btnSend) el.btnSend.click();\n}\n\nfunction setGallerySelectionByElement(element, options) {\n if (!gallerySelection.files.length) refreshGallerySelection();\n let index = gallerySelection.files.findIndex((file) => file === element);\n if (index < 0) {\n refreshGallerySelection();\n index = gallerySelection.files.findIndex((file) => file === element);\n }\n if (index >= 0) applyGallerySelection(index, options);\n}\n\nfunction buildGalleryFileUrl(path) {\n return new URL(`/file=${encodeURI(path)}`, window.location.origin).toString();\n}\n\nwindow.getGallerySelection = () => ({ index: gallerySelection.index, files: gallerySelection.files });\nwindow.setGallerySelection = (index, options) => applyGallerySelection(index, options);\nwindow.getGallerySelectedUrl = () => (currentImage ? buildGalleryFileUrl(currentImage) : null);\n\n/**\n * Wait for gallery to finish populating\n * @param {number} expectedSize - Expected gallery size\n * @param {AbortSignal} signal - AbortController signal\n */\nasync function awaitForGallery(expectedSize, signal) {\n while (Math.max(galleryHashes.size, galleryHashes.fallback) < expectedSize && !signal.aborted) await new Promise((resolve) => { setTimeout(resolve, 500); }); // longer interval because it's a low priority check\n signal.throwIfAborted();\n}\n\nfunction updateGalleryStyles() {\n if (opts.theme_type?.toLowerCase() === 'modern') {\n folderStylesheet.replace(`\n .gallery-folder {\n cursor: pointer;\n padding: 8px 6px 8px 6px;\n background-color: var(--sd-button-normal-color);\n border-radius: var(--sd-border-radius);\n text-align: left;\n direction: rtl; /* Used to overflow the beginning instead of the end */\n min-width: 12em;\n max-width: 100%;\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n transition-duration: 0.2s;\n transition-property: color, opacity, background-color, border-color;\n transition-timing-function: ease-out;\n }\n .gallery-folder:hover {\n background-color: var(--button-primary-background-fill-hover, var(--sd-button-hover-color));\n }\n .gallery-folder-selected {\n background-color: var(--sd-button-selected-color);\n color: var(--sd-button-selected-text-color);\n }\n .gallery-folder-icon {\n font-size: 1.2em;\n color: var(--sd-button-icon-color);\n margin-right: 1em;\n filter: drop-shadow(1px 1px 2px black);\n float: left;\n }\n `);\n } else {\n folderStylesheet.replace(`\n .gallery-folder {\n cursor: pointer;\n padding: 8px 6px 8px 6px;\n max-width: 200px;\n overflow-x: hidden;\n text-wrap: nowrap;\n text-overflow: ellipsis;\n }\n .gallery-folder:hover {\n background-color: var(--button-primary-background-fill-hover);\n }\n .gallery-folder-selected {\n background-color: var(--button-primary-background-fill);\n }\n `);\n }\n const size = el.size ? el.size.value : opts.extra_networks_card_size;\n fileStylesheet.replace(`\n .gallery-file {\n object-fit: contain;\n cursor: pointer;\n height: ${size}px;\n width: ${opts.browser_fixed_width ? `${size}px` : 'unset'};\n }\n .gallery-file:hover {\n filter: grayscale(100%);\n }\n .gallery-overlay {\n position: absolute;\n height: 24px;\n background-color: rgba(0,0,0,0.7);\n display: block;\n text-align: right;\n padding: 4px;\n font-size: 1.2em;\n letter-spacing: 0.5em;\n margin-top: calc(140px - 32px);\n opacity: 75%;\n border-radius: var(--sd-border-radius);\n }\n :host(.gallery-file-selected) .gallery-file {\n box-shadow: 0 0 0 2px var(--sd-button-selected-color);\n }\n `);\n}\n\n// Classes\n\nclass HashSet extends Set {\n fallback = 0;\n constructor(val?: any) {\n super(val);\n this.fallback = 0;\n }\n\n override add(value: any): this {\n ++this.fallback;\n super.add(value);\n return this;\n }\n\n override clear(): void {\n this.fallback = 0;\n super.clear();\n }\n}\n\nconst galleryHashes = new HashSet();\n\nclass SimpleProgressBar {\n #container = document.createElement('div');\n #progress = document.createElement('div');\n #textDiv = document.createElement('div');\n #text = document.createElement('span');\n #visible = false;\n #interval: ReturnType | undefined;\n #max = 0;\n defaultStats = { queue: 0, fetch: 0, hash: 0, db: 0, cached: 0, fetched: 0, failed: 0, error: 0, callback: 0, elapsed: 0, count: 0 };\n stats = { ...this.defaultStats };\n /** @type {Set} */\n #monitoredSet;\n\n constructor(monitoredSet) {\n this.#monitoredSet = monitoredSet; // This is required because incrementing a variable with a class method turned out to not be an atomic operation\n this.#container.style.cssText = 'position:relative; overflow:hidden; border-radius:var(--sd-border-radius); width:100%; background-color:hsla(0,0%,36%,0.3); height:1.2rem; margin:0; padding:0; display:none;';\n this.#progress.style.cssText = 'position:absolute; left:0; height:100%; width:0; transition:width 200ms;';\n this.#progress.style.backgroundColor = 'var(--sd-main-accent-color)';\n this.#textDiv.style.cssText = 'position:relative; margin:auto; width:max-content; height:100%;';\n this.#text.style.cssText = 'user-select:none; color:white;';\n this.#textDiv.append(this.#text);\n this.#container.append(this.#progress, this.#textDiv);\n }\n\n start(total) {\n if (total <= 0) return;\n this.hide();\n this.#max = total;\n if (this.#monitoredSet.size >= this.#max) {\n this.stop();\n return;\n }\n this.#interval = setInterval(() => this.update(this.#monitoredSet.size, this.#max), 100);\n }\n\n attachTo(element) {\n if (element.hasChildNodes) element.innerHTML = '';\n element.appendChild(this.#container);\n }\n\n hide() {\n this.#container.style.display = 'none';\n this.#visible = false;\n this.#progress.style.width = '0';\n this.#text.textContent = '';\n }\n\n update(loaded, max) {\n this.#progress.style.width = `${Math.floor((loaded / max) * 100)}%`;\n this.#text.textContent = `${loaded}/${max}`;\n if (!this.#visible) {\n this.#container.style.display = 'block';\n this.#visible = true;\n }\n if (loaded >= max) this.stop();\n }\n\n stop() {\n clearInterval(this.#interval);\n // this.#interval = undefined;\n if (this.stats.count) {\n debug('gallery: thumbnail stats', this.stats);\n this.stats = { ...this.defaultStats };\n }\n setTimeout(() => this.hide(), 100);\n }\n}\n\nconst pb = new SimpleProgressBar(galleryHashes);\n\n/* This isn't as robust as the Web Locks API, but it will at least work if accessing a remote machine without HTTPS */\nclass SimpleFunctionQueue {\n #id;\n #running;\n #queue;\n\n constructor(id) {\n this.#id = id;\n this.#running = false;\n this.#queue = [];\n }\n\n static abortLogger(identifier, result) {\n if (typeof result === 'string' || (result instanceof DOMException && result.name === 'AbortError')) {\n log(identifier, typeof result === 'object' && result !== null ? (result as any).message || result : result);\n } else {\n error(identifier, result.message);\n }\n }\n\n /**\n * @param {{\n * signal: AbortSignal,\n * callback: Function\n * }} config\n */\n enqueue(config) {\n if (!(config.signal instanceof AbortSignal) || typeof config.callback !== 'function') {\n throw new Error('Invalid configuration. Object must contain an AbortSignal and a function');\n }\n if (config.signal.aborted) {\n debug(`${this.#id} Queue: Skipping addition to queue due to \"${config.signal.reason}\"`);\n return;\n }\n this.#queue.push(config);\n this.#tryRunNext();\n }\n\n async #tryRunNext() {\n if (this.#running || !this.#queue.length) return;\n try {\n const { signal, callback } = this.#queue.shift();\n if (signal.aborted) {\n return;\n }\n this.#running = true;\n if (callback.constructor.name.toLowerCase() === 'asyncfunction') {\n await callback();\n } else {\n callback();\n }\n } catch (err) {\n error(`${this.#id} Queue:`, err);\n } finally {\n this.#running = false;\n this.#tryRunNext();\n }\n }\n}\n\n// HTML Elements\n\nclass GalleryFolder extends HTMLElement {\n static folders = new Set();\n /** @type {GalleryFolder | null} */\n static #active = null;\n\n constructor(folder) {\n super();\n // Support both old format (string) and new format (object with path and label)\n if (typeof folder === 'object' && folder !== null) {\n this.name = decodeURI(folder.path || '');\n this.label = decodeURI(folder.label || folder.path || '');\n } else {\n this.name = decodeURI(folder);\n this.label = this.name;\n }\n this.style.overflowX = 'hidden';\n this.shadow = this.attachShadow({ mode: 'open' });\n this.shadow.adoptedStyleSheets = [folderStylesheet];\n\n this.div = document.createElement('div');\n }\n\n connectedCallback() {\n if (GalleryFolder.folders.has(this)) return; // Element is just being moved\n this.div.className = 'gallery-folder';\n this.div.innerHTML = `\\uf03e ${this.label}`;\n this.div.title = this.name; // Show full path on hover\n this.addEventListener('click', this.updateSelected);\n this.addEventListener('click', fetchFilesWS);\n this.shadow.appendChild(this.div);\n GalleryFolder.folders.add(this);\n if (this.name === currentGalleryFolder) {\n this.updateSelected();\n }\n }\n\n async disconnectedCallback() {\n await Promise.resolve(); // Wait for other microtasks (such as element moving)\n if (this.isConnected) return;\n GalleryFolder.folders.delete(this);\n if (GalleryFolder.#active === this) {\n GalleryFolder.#active = null;\n }\n }\n\n static getActive() {\n return GalleryFolder.#active;\n }\n\n updateSelected() {\n this.div.classList.add('gallery-folder-selected');\n GalleryFolder.#active = this;\n for (const folder of GalleryFolder.folders as any) {\n if (folder !== this) folder.div.classList.remove('gallery-folder-selected');\n }\n }\n}\n\n/**\n * Event-driven wait mechanism replacing the 50ms polling loop\n * @param {AbortSignal} signal - AbortController signal\n */\nasync function awaitForOutstanding(signal) {\n if (signal?.aborted) throw new DOMException('Aborted', 'AbortError');\n if (outstanding < maxFetchRequests) return; // if we are under the limit, proceed immediately\n await new Promise((resolve, reject) => { // otherwise, register a promise and wait for the queue to resolve us\n const onResolve = () => { // define what happens when this item gets its turn or gets aborted\n signal?.removeEventListener('abort', onAbort);\n resolve(true);\n };\n const onAbort = () => {\n const idx = fetchQueue.findIndex((item) => item.resolve === onResolve); // remove this specific request from the waiting queue if aborted\n if (idx !== -1) fetchQueue.splice(idx, 1);\n reject(new DOMException('Aborted', 'AbortError'));\n };\n fetchQueue.push({ resolve: onResolve });\n signal?.addEventListener('abort', onAbort);\n });\n}\n\nasync function delayFetchThumb(fn, signal) {\n const t0 = performance.now();\n try {\n await awaitForOutstanding(signal);\n } catch (err) {\n if ((err as DOMException).name === 'AbortError') return undefined;\n throw err;\n }\n pb.stats.queue = (pb.stats.queue || 0) + Math.round(performance.now() - t0);\n const t1 = performance.now();\n try {\n outstanding++;\n const ts = t0.toString();\n const res = await authFetch(`${window.api}/browser/thumb?file=${encodeURI(fn)}&ts=${ts}&exif=false`, { priority: 'low' });\n if (!res.ok) {\n error(`fetchThumb: ${res.statusText}`);\n return undefined;\n }\n const json = await res.json();\n if (!res || !json || json.error || Object.keys(json).length === 0) {\n if (json.error) error(`fetchThumb: ${json.error}`);\n return undefined;\n }\n return json;\n } finally {\n outstanding--;\n pb.stats.fetch = (pb.stats.fetch || 0) + Math.round(performance.now() - t1);\n if (fetchQueue.length > 0 && outstanding < maxFetchRequests) { // queue magic: trigger the next waiting fetch immediately\n const nextRequest = fetchQueue.shift();\n nextRequest.resolve(); // This wakes up the next awaitForOutstanding()\n }\n }\n}\n\nclass GalleryFile extends HTMLElement {\n /** @type {AbortSignal} */\n #signal;\n\n constructor(folder, file, signal) {\n super();\n this.folder = folder;\n this.name = file;\n this.#signal = signal;\n this.src = `${this.folder}/${this.name}`.replace(/\\/+/g, '/'); // Ensure no //, ///, etc...\n this.fullFolder = this.src.replace(/\\/[^/]+$/, '');\n this.size = 0;\n this.mtime = 0;\n this.hash = undefined;\n this.exif = '';\n this.width = 0;\n this.height = 0;\n this.shadow = this.attachShadow({ mode: 'open' });\n this.shadow.adoptedStyleSheets = [fileStylesheet];\n this.firstRun = true;\n }\n\n async connectedCallback() {\n if (!this.firstRun) return; // Element is just being moved\n this.firstRun = false;\n const t0 = performance.now();\n pb.stats.count = (pb.stats.count || 0) + 1;\n // Check separator state early to hide the element immediately\n const dir = this.name.match(/(.*)[/\\\\]/);\n if (dir && dir[1]) {\n const dirPath = dir[1];\n const isOpen = separatorStates.get(dirPath);\n if (isOpen === false) this.style.display = 'none';\n }\n\n this.hash = await getHash(`${this.src}/${this.size}/${this.mtime}`)\n .catch((err) => {\n error('getHash:', err);\n return null;\n });\n pb.stats.hash = (pb.stats.hash || 0) + Math.round(performance.now() - t0);\n let cachedData;\n if (opts.browser_cache) {\n const t1 = performance.now();\n // if (!pb.stats.keys) pb.stats.keys = await idbKeys();\n // if (pb.stats.keys && this.hash && pb.stats.keys.includes(this.hash)) cachedData = await idbGet(this.hash).catch(() => undefined);\n cachedData = await idbGet(this.hash).catch(() => undefined);\n pb.stats.db = (pb.stats.db || 0) + Math.round(performance.now() - t1);\n }\n const img = document.createElement('img');\n img.className = 'gallery-file';\n img.loading = 'lazy';\n img.onload = async () => {\n img.title += `\\nResolution: ${this.width} x ${this.height}`;\n this.title = img.title;\n if (!cachedData && opts.browser_cache) {\n if ((this.width === 0) || (this.height === 0)) { // fetch thumb failed so we use actual image\n this.width = img.naturalWidth;\n this.height = img.naturalHeight;\n }\n }\n };\n let ok = true;\n if (cachedData?.img) {\n img.src = cachedData.img;\n this.exif = cachedData.exif;\n this.width = cachedData.width;\n this.height = cachedData.height;\n this.size = cachedData.size;\n this.mtime = new Date(cachedData.mtime);\n pb.stats.cached = (pb.stats.cached || 0) + 1;\n } else {\n try {\n const json = await delayFetchThumb(this.src, this.#signal);\n if (!json) {\n ok = false;\n pb.stats.failed = (pb.stats.failed || 0) + 1;\n } else {\n img.src = json.data;\n this.exif = json.exif;\n this.width = json.width;\n this.height = json.height;\n this.size = json.size;\n this.mtime = new Date(json.mtime);\n pb.stats.fetched = (pb.stats.fetched || 0) + 1;\n if (opts.browser_cache && this.hash) {\n idbAdd({\n hash: this.hash,\n folder: this.fullFolder,\n file: this.name,\n size: this.size,\n mtime: this.mtime,\n width: this.width,\n height: this.height,\n src: this.src,\n exif: this.exif,\n img: img.src,\n // exif: await getExif(img), // alternative client-side exif\n // img: await createThumb(img), // alternative client-side thumb\n });\n }\n }\n } catch (err) { // thumb fetch failed so assign actual image\n img.src = `file=${this.src}`;\n pb.stats.error = (pb.stats.error || 0) + 1;\n }\n }\n pb.stats.callback = (pb.stats.callback || 0) + Math.round(performance.now() - t0);\n if (this.#signal.aborted) return;\n galleryHashes.add(this.hash);\n if (!ok) return;\n\n img.onclick = () => {\n setGallerySelectionByElement(this, { send: true });\n };\n img.onpointerenter = () => {\n el.overlay.display = 'block';\n this.shadow.appendChild(el.overlay);\n currentImage = this.src;\n currentName = this.name;\n currentTitle = this.title;\n };\n img.onpointerleave = () => {\n el.overlay.display = 'none';\n };\n img.title = `Folder: ${this.folder}\\nFile: ${this.name}\\nSize: ${this.size.toLocaleString()} bytes\\nModified: ${this.mtime.toLocaleString()}`;\n this.title = img.title;\n const shouldDisplayBasedOnSearch = this.title.toLowerCase().includes(el.search.value.toLowerCase()); // Final visibility check based on search term.\n if (this.style.display !== 'none') this.style.display = shouldDisplayBasedOnSearch ? '' : 'none'; // Only proceed if not already hidden by a closed separator\n this.shadow.appendChild(img);\n pb.stats.elapsed = (pb.stats.elapsed || 0) + Math.round(performance.now() - t0);\n }\n}\n\nasync function createThumb(img) {\n const sizeEl = document.getElementById('gallery-thumb-size');\n currentSize = sizeEl ? parseInt(sizeEl.value, 10) : opts.extra_networks_card_size;\n const height = currentSize;\n const width = opts.browser_fixed_width ? currentSize : 0;\n const canvas = document.createElement('canvas');\n const scaleY = height / img.height;\n const scaleX = width > 0 ? width / img.width : scaleY;\n const scale = Math.min(scaleX, scaleY);\n const scaledWidth = img.width * scale;\n const scaledHeight = img.height * scale;\n canvas.width = scaledWidth;\n canvas.height = scaledHeight;\n const ctx = canvas.getContext('2d');\n ctx.drawImage(img, 0, 0, scaledWidth, scaledHeight);\n const dataURL = canvas.toDataURL('image/jpeg', 0.5);\n return dataURL;\n}\n\nasync function handleSeparator(separator) {\n separator.classList.toggle('gallery-separator-hidden');\n const nowHidden = separator.classList.contains('gallery-separator-hidden');\n\n // Store the state (true = open, false = closed)\n separatorStates.set(separator.title, !nowHidden);\n\n // Update arrow and count\n const arrow = separator.querySelector('.gallery-separator-arrow');\n arrow.style.transform = nowHidden ? 'rotate(0deg)' : 'rotate(90deg)';\n\n const all = Array.from(el.files.children);\n for (const f of all) {\n if (!f.name) continue; // Skip separators\n\n // Check if file belongs to this exact directory\n const fileDir = f.name.match(/(.*)[/\\\\]/);\n const fileDirPath = fileDir ? fileDir[1] : '';\n\n if (separator.title.length > 0 && fileDirPath === separator.title) {\n f.style.display = nowHidden ? 'none' : '';\n }\n }\n // Note: Count is not updated here on manual toggle, as it reflects the total.\n // If I end up implementing it, the search function will handle dynamic count updates.\n}\n\nasync function addSeparators() {\n document.querySelectorAll('.gallery-separator').forEach((node) => { el.files.removeChild(node); });\n const all = Array.from(el.files.children);\n let lastDir;\n\n // Count root files (files without a directory path)\n const hasRootFiles = all.some((f) => f.name && !f.name.match(/[/\\\\]/));\n // Only auto-open first separator if there are no root files to display\n let isFirstSeparator = !hasRootFiles;\n\n // First pass: create separators\n for (const f of all) {\n let dir = f.name?.match(/(.*)[/\\\\]/);\n if (!dir) dir = '';\n else dir = dir[1];\n if (dir !== lastDir) {\n lastDir = dir;\n if (dir.length > 0) {\n // Count files in this directory\n let fileCount = 0;\n for (const file of all) {\n if (!file.name) continue;\n const fileDir = file.name.match(/(.*)[/\\\\]/);\n const fileDirPath = fileDir ? fileDir[1] : '';\n if (fileDirPath === dir) fileCount++;\n }\n\n const sep = document.createElement('div');\n sep.className = 'gallery-separator';\n sep.title = dir;\n\n // Default to open for the first separator if no state is saved, otherwise closed.\n const isOpen = separatorStates.has(dir) ? separatorStates.get(dir) : isFirstSeparator;\n separatorStates.set(dir, isOpen); // Ensure it's in the map\n if (isFirstSeparator) isFirstSeparator = false; // Subsequent separators will default to closed\n\n if (!isOpen) {\n sep.classList.add('gallery-separator-hidden');\n }\n\n // Create arrow span\n const arrow = document.createElement('span');\n arrow.className = 'gallery-separator-arrow';\n arrow.textContent = '\u25B6';\n arrow.style.transform = isOpen ? 'rotate(90deg)' : 'rotate(0deg)';\n\n // Create directory name span\n const dirName = document.createElement('span');\n dirName.className = 'gallery-separator-name';\n dirName.textContent = dir;\n dirName.title = dir; // Show full path on hover\n\n // Create count span\n const count = document.createElement('span');\n count.className = 'gallery-separator-count';\n count.textContent = `${fileCount} files`;\n sep.dataset.totalFiles = String(fileCount); // Store total count for search filtering\n\n sep.appendChild(arrow);\n sep.appendChild(dirName);\n sep.appendChild(count);\n\n sep.onclick = () => handleSeparator(sep);\n el.files.insertBefore(sep, f);\n }\n }\n }\n\n // Second pass: hide files in closed directories\n for (const f of all) {\n if (!f.name) continue; // Skip separators\n\n const dir = f.name.match(/(.*)[/\\\\]/);\n if (dir && dir[1]) {\n const dirPath = dir[1];\n const isOpen = separatorStates.get(dirPath);\n if (isOpen === false) {\n f.style.display = 'none';\n }\n }\n }\n}\n\n// methods\n\nconst gallerySendImage = (_images) => [currentImage]; // invoked by gradio button\nwindow.gallerySendImage = gallerySendImage;\n\n/**\n * Helper function to update status with sort mode\n * @param {...string|[string, string]} messages - Each can be either a string to use as-is, or an array of a string label and value\n * @returns {void}\n */\nfunction updateStatusLine(...messages) {\n if (!el.status) return;\n messages.unshift(['Sort', sortMode.name]);\n const fragment = document.createDocumentFragment();\n for (let i = 0; i < messages.length; i++) {\n const div = document.createElement('div');\n if (Array.isArray(messages[i])) {\n const [k, v] = messages[i];\n const tDiv = document.createElement('div');\n const ico = icons[k] || `${k}:`;\n tDiv.innerText = `${ico} ${v}`;\n div.append(tDiv);\n } else {\n const tDiv = document.createElement('div');\n tDiv.innerText = messages[i];\n div.append(tDiv);\n }\n fragment.append(div);\n }\n if (el.status.hasChildNodes()) el.status.innerHTML = '';\n el.status.append(fragment);\n}\n\nasync function injectGalleryStatusCSS() {\n const style = document.createElement('style');\n style.textContent = `\n #tab-gallery-status {\n display: inline-flex;\n flex-flow: row wrap;\n justify-content: ${opts.theme_type?.toLowerCase() === 'modern' ? 'flex-start' : 'flex-end'};\n }\n #tab-gallery-status > div {\n display: flex;\n max-width: 100%;\n white-space: nowrap;\n & div {\n &:first-child {\n flex-shrink: 0;\n margin-right: 4px;\n }\n &:last-child:not(:first-child) {\n flex-shrink: 1;\n overflow: hidden;\n text-overflow: ellipsis;\n white-space: nowrap;\n direction: rtl;\n text-align: left;\n }\n }\n }\n #tab-gallery-status > div:not(:last-child)::after {\n content: '|';\n margin-inline: 6px;\n }`;\n document.head.append(style);\n}\n\nasync function wsConnect(socket, timeout = 5000) {\n const intrasleep = 100;\n const ttl = timeout / intrasleep;\n const isOpened = () => (socket.readyState === WebSocket.OPEN);\n if (socket.readyState !== WebSocket.CONNECTING) return isOpened();\n\n let loop = 0;\n while (socket.readyState === WebSocket.CONNECTING && loop < ttl) {\n await new Promise((resolve) => { setTimeout(resolve, intrasleep); });\n loop++;\n }\n return isOpened();\n}\n\nasync function gallerySearch() {\n if (el.search.busy) clearTimeout(el.search.busy);\n el.search.busy = setTimeout(async () => {\n const t0 = performance.now();\n const str = el.search.value.toLowerCase();\n const allFiles = Array.from(el.files.children).filter((node) => node.name);\n const allSeparators = Array.from(el.files.children).filter((node) => node.classList.contains('gallery-separator'));\n\n // If search is cleared, restore original view\n if (str === '') {\n allSeparators.forEach((sep) => {\n sep.style.display = 'flex';\n const isOpen = separatorStates.has(sep.title) ? separatorStates.get(sep.title) : false;\n\n const countSpan = sep.querySelector('.gallery-separator-count');\n if (countSpan && sep.dataset.totalFiles) {\n countSpan.textContent = `${sep.dataset.totalFiles} files`;\n }\n\n const arrow = sep.querySelector('.gallery-separator-arrow');\n sep.classList.toggle('gallery-separator-hidden', !isOpen);\n if (arrow) arrow.style.transform = isOpen ? 'rotate(90deg)' : 'rotate(0deg)';\n });\n\n allFiles.forEach((f) => {\n const dir = f.name.match(/(.*)[/\\\\]/);\n const dirPath = (dir && dir[1]) ? dir[1] : '';\n const isOpen = separatorStates.get(dirPath);\n f.style.display = (!dirPath || isOpen) ? 'unset' : 'none';\n });\n\n updateStatusLine('Filter', 'Cleared', ['Images', allFiles.length.toLocaleString()]);\n return;\n }\n\n // --- Search logic ---\n let totalFound = 0;\n const directoryMatches = new Map();\n const fileMatches = new WeakSet();\n const r = /^(.+)([=<>])(.*)/;\n\n for (const f of allFiles) {\n let isMatch = false;\n if (r.test(str)) {\n const match = str.match(r);\n const key = match[1].trim();\n const op = match[2].trim();\n let val = match[3].trim();\n if (key === 'mtime') val = new Date(val);\n if (((op === '=') && (f[key] === val)) || ((op === '>') && (f[key] > val)) || ((op === '<') && (f[key] < val))) {\n isMatch = true;\n }\n } else if (f.title?.toLowerCase().includes(str) || f.exif?.toLowerCase().includes(str)) {\n isMatch = true;\n }\n\n if (isMatch) {\n fileMatches.add(f);\n totalFound++;\n const dir = f.name.match(/(.*)[/\\\\]/);\n const dirPath = (dir && dir[1]) ? dir[1] : '';\n directoryMatches.set(dirPath, (directoryMatches.get(dirPath) || 0) + 1);\n }\n }\n\n // Update separators based on search results\n for (const sep of allSeparators) {\n const dirPath = sep.title;\n const foundCount = directoryMatches.get(dirPath) || 0;\n\n if (foundCount > 0) {\n sep.style.display = 'flex'; // Show separator\n sep.classList.remove('gallery-separator-hidden'); // Force open\n\n const arrow = sep.querySelector('.gallery-separator-arrow');\n if (arrow) arrow.style.transform = 'rotate(90deg)';\n\n // Removed file count update during search as it was buggy.\n } else {\n sep.style.display = 'none'; // Hide separator\n }\n }\n\n // Update file visibility\n for (const f of allFiles) {\n f.style.display = fileMatches.has(f) ? 'unset' : 'none';\n }\n\n const t1 = performance.now();\n updateStatusLine('Filter', ['Images', `${totalFound.toLocaleString()} / ${allFiles.length.toLocaleString()}`], ['Time', `${Math.round(t1 - t0).toLocaleString()}ms`]);\n timer(`galleryFilter:${str}`, t1 - t0);\n refreshGallerySelection();\n }, 250);\n}\n\nconst findDuplicates = (arr, key) => {\n const map = new Map();\n return arr.filter((item) => {\n const value = item[key];\n if (map.has(value)) return true;\n map.set(value, true);\n return false;\n });\n};\n\nexport async function gallerySort(key) {\n // if currentSort does not start with key, default to key+A\n // else if currentSort ends with A change to D and vice versa for toggling sort order\n if (currentSort.startsWith(key)) currentSort = currentSort.endsWith('A') ? `${key}D` : `${key}A`;\n else currentSort = `${key}A`;\n\n if (!Object.hasOwn(gallerySorter, currentSort)) {\n error(`Gallery: \"${currentSort}\" is not a valid gallery sorting key`);\n return;\n }\n const t0 = performance.now();\n const arr = Array.from(el.files.children).filter((node) => node.name); // filter out separators\n if (arr.length === 0) return; // no files to sort\n const fragment = document.createDocumentFragment();\n\n // Helper to get directory path from a file node\n const getDirPath = (node) => {\n const match = node.name.match(/(.*)[/\\\\]/);\n return match ? match[1] : '';\n };\n\n // Partition into root files and subfolder files - root files always stay at top\n const rootFiles = arr.filter((node) => !getDirPath(node));\n const subfolderFiles = arr.filter((node) => getDirPath(node));\n\n // Group subfolder files by directory\n const folderGroups = new Map();\n for (const file of subfolderFiles) {\n const dir = getDirPath(file);\n if (!folderGroups.has(dir)) folderGroups.set(dir, []);\n folderGroups.get(dir).push(file);\n }\n\n sortMode = gallerySorter[currentSort];\n\n // Sort root files\n rootFiles.sort(sortMode.func);\n rootFiles.forEach((node) => fragment.appendChild(node));\n\n // Sort folder names alphabetically, then sort files within each folder\n // const sortedFolderNames = Array.from(folderGroups.keys()).sort((a, b) => a.localeCompare(b));\n const folderNames = Array.from(folderGroups.keys());\n const sortedFolderNames = currentSort.endsWith('A') ? folderNames.sort((a, b) => a.localeCompare(b)) : folderNames.sort((a, b) => b.localeCompare(a));\n\n console.log('HERE', sortedFolderNames);\n for (const folderName of sortedFolderNames) {\n const files = folderGroups.get(folderName);\n files.sort(sortMode.func);\n files.forEach((node) => fragment.appendChild(node));\n }\n\n if (fragment.children.length === 0) return;\n el.files.innerHTML = '';\n el.files.appendChild(fragment);\n addSeparators();\n\n // After sorting and adding separators, ensure files respect separator states\n const all = Array.from(el.files.children);\n for (const f of all) {\n if (!f.name) continue; // Skip separators\n\n const dir = f.name.match(/(.*)[/\\\\]/);\n if (dir && dir[1]) {\n const dirPath = dir[1];\n const isOpen = separatorStates.get(dirPath);\n if (isOpen === false) {\n f.style.display = 'none';\n }\n }\n }\n\n const t1 = performance.now();\n log(`gallerySort: sort=${sortMode.name} len=${arr.length} time=${Math.floor(t1 - t0)}`);\n updateStatusLine(['Images', arr.length.toLocaleString()], ['Time', `${Math.round(t1 - t0).toLocaleString()}ms`]);\n timer(`gallerySort:${sortMode.name}`, t1 - t0);\n refreshGallerySelection();\n}\nwindow.gallerySort = gallerySort;\n\n/**\n * Function for removing the cleaning overlay\n * @callback ClearMsgCallback\n * @returns {void}\n */\n\n/**\n * Generate and display the overlay to announce cleanup is in progress.\n * @param {number} count - Number of entries being cleaned up\n * @param {boolean} all - Indicate that all thumbnails are being cleared\n * @returns {ClearMsgCallback}\n */\nfunction showCleaningMsg(count, all = false) {\n // Rendering performance isn't a priority since this doesn't run often\n const parent = el.folders.parentElement;\n const cleaningOverlay = document.createElement('div');\n const msgDiv = document.createElement('div');\n const msgText = document.createElement('div');\n const msgInfo = document.createElement('div');\n const anim = document.createElement('span');\n\n parent.style.position = 'relative';\n cleaningOverlay.style.cssText = 'position: absolute; height: 100%; width: 100%; background-color: var(--sd-main-accent-color); display: flex; align-items: center; justify-content: center; align-content: center; flex-wrap: wrap; opacity: 0.8; border-radius: var(--sd-border-radius);';\n msgDiv.style.cssText = 'display: block; color: var(--sd-button-normal-color); padding: 12px; border-radius: 8px; border-radius: var(--sd-border-radius);';\n msgText.style.cssText = 'font-size: 1.2em';\n msgInfo.style.cssText = 'font-size: 0.9em; text-align: center;';\n msgText.innerText = 'Thumbnail cleanup...';\n msgInfo.innerText = all ? 'Clearing all entries' : `Found ${count} old entries`;\n anim.classList.add('idbBusyAnim');\n\n msgDiv.append(msgText, msgInfo);\n cleaningOverlay.append(msgDiv, anim);\n parent.append(cleaningOverlay);\n return () => { cleaningOverlay.remove(); };\n}\n\nconst maintenanceQueue = new SimpleFunctionQueue('Gallery Maintenance');\n\n/**\n * Handles calling the cleanup function for the thumbnail cache\n * @param {string} folder - Folder to clean\n * @param {number} imgCount - Expected number of images in gallery\n * @param {AbortController} controller - AbortController that's handling this task\n * @param {boolean} force - Force full cleanup of the folder\n */\nasync function thumbCacheCleanup(folder, imgCount, controller, force = false) {\n if (!opts.browser_cache && !force) return;\n if (!folder || !imgCount) return;\n if (Date.now() - cleanupTimers[folder] < minCleanupTime) return; // Prevents multiple calls in quick succession\n cleanupTimers[folder] = Date.now();\n try {\n if (typeof folder !== 'string' || typeof imgCount !== 'number') {\n throw new Error('Function called with invalid arguments');\n }\n debug('thumbCacheCleanup', { folder, imgCount });\n await awaitForGallery(imgCount, controller.signal);\n } catch (err) {\n error('thumbCacheCleanup', { folder, error: err });\n return;\n }\n\n maintenanceQueue.enqueue({\n signal: controller.signal,\n callback: async () => {\n if (Date.now() - maintenanceTimers[folder] < minCleanupTime) return;\n maintenanceTimers[folder] = Date.now();\n const t0 = performance.now();\n const keptGalleryHashes = force ? new Set() : new Set(galleryHashes.values()); // External context should be safe since this function run is guarded by AbortController/AbortSignal in the SimpleFunctionQueue\n const folderNormalized = folder.replace(/\\/+/g, '/').replace(/\\/$/, '');\n const recursiveFolder = IDBKeyRange.bound(folderNormalized, `${folderNormalized}\\uffff`, false, true);\n if (keptGalleryHashes.size < minCleanupCount && !force) return; // Don't run when there aren't many excess entries\n const cachedHashesCount = await idbCount(recursiveFolder)\n .catch((e) => {\n error('maintenanceQueue', { folder, error: e });\n return Infinity; // Forces next check to fail if something went wrong\n });\n const cleanupCount = cachedHashesCount - keptGalleryHashes.size;\n if (!force && (cleanupCount < minCleanupCount || !Number.isFinite(cleanupCount))) return; // Don't run when there aren't many excess entries\n log('galleryMaintenance', { folder });\n\n if (controller.signal.aborted) {\n debug('maintenanceQueue', { folder, reason: controller.signal.reason });\n return;\n }\n const cb_clearMsg = showCleaningMsg(cleanupCount);\n await idbFolderCleanup(keptGalleryHashes, recursiveFolder, controller.signal)\n .then((delcount) => {\n const t1 = performance.now();\n log('galleryMaintenance', { folder, kept: keptGalleryHashes.size, deleted: delcount, time: Math.round(t1 - t0) });\n timer(`thumbnailDBCleanup:${folder}`, t1 - t0);\n currentGalleryFolder = null;\n updateStatusLine('Thumbnail cache cleared');\n })\n .catch((reason) => {\n SimpleFunctionQueue.abortLogger('thumbCacheCleanup', reason);\n })\n .finally(async () => {\n await new Promise((resolve) => { setTimeout(resolve, 1000); }); // Delay removal by 1 second to ensure at least minimum visibility\n cb_clearMsg();\n });\n },\n });\n}\n\nfunction resetGalleryState(reason) {\n maintenanceController.abort(reason);\n const controller = new AbortController();\n maintenanceController = controller;\n\n galleryHashes.clear(); // Must happen AFTER the AbortController steps\n pb.hide();\n resetGallerySelection();\n return controller;\n}\n\nfunction clearCacheIfDisabled(browser_cache) {\n if (browser_cache === false) {\n log('thumbCacheCleanup', { disabled: true });\n const controller = resetGalleryState('Clearing all thumbnails from cache');\n maintenanceQueue.enqueue({\n signal: controller.signal,\n callback: async () => {\n const t0 = performance.now();\n const cb_clearMsg = showCleaningMsg(0, true);\n await idbClearAll(controller.signal)\n .then(() => {\n log('thumbCacheCleanup', { time: Math.floor(performance.now() - t0) });\n currentGalleryFolder = null;\n updateStatusLine('Thumbnail cache cleared');\n })\n .catch((e) => {\n SimpleFunctionQueue.abortLogger('thumbCacheCleanup', e);\n })\n .finally(async () => {\n await new Promise((resolve) => { setTimeout(resolve, 1000); });\n cb_clearMsg();\n });\n },\n });\n }\n}\n\nexport function clearCache() {\n if (!currentGalleryFolder) return;\n const controller = resetGalleryState('Clearing folder thumbnails cache');\n el.files.innerHTML = '';\n log('clearCache', { folder: currentGalleryFolder });\n thumbCacheCleanup(currentGalleryFolder, 0, controller, true);\n}\nwindow.clearCache = clearCache;\n\nasync function fetchFilesHT(evt, controller) {\n const t0 = performance.now();\n const fragment = document.createDocumentFragment();\n updateStatusLine(['Folder', evt.target.name], 'in-progress');\n let numFiles = 0;\n\n const res = await authFetch(`${window.api}/browser/files?folder=${encodeURI(evt.target.name)}`);\n if (!res || res.status !== 200) {\n updateStatusLine(['Folder', evt.target.name], ['Failed', res?.statusText || 'No response']);\n return;\n }\n const jsonData = await res.json();\n for (const line of jsonData) {\n const data = decodeURI(line).split('##F##');\n const fileName = data[1];\n const ext = fileName.split('.').pop().toLowerCase();\n if (SUPPORTED_EXTENSIONS.includes(ext)) {\n numFiles++;\n const f = new GalleryFile(data[0], fileName, controller.signal);\n fragment.appendChild(f);\n }\n }\n\n if (controller.signal.aborted) return;\n el.files.appendChild(fragment);\n\n const t1 = performance.now();\n log(`gallery: folder=${evt.target.name} num=${numFiles} method=http time=${Math.floor(t1 - t0)}ms`);\n timer(`galleryFetch:${evt.target.name}`, t1 - t0);\n updateStatusLine(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], ['Time', `${Math.floor(t1 - t0).toLocaleString()}ms`]);\n pb.start(numFiles);\n addSeparators();\n refreshGallerySelection();\n thumbCacheCleanup(evt.target.name, numFiles, controller);\n}\n\nasync function fetchFilesWS(evt) { // fetch file-by-file list over websockets\n if (!url) return;\n // Abort previous controller and point to new controller for next time\n const controller = resetGalleryState('Gallery update'); // Called here because fetchFilesHT isn't called directly\n\n el.files.innerHTML = '';\n updateGalleryStyles();\n if (ws && ws.readyState === WebSocket.OPEN) ws.close(); // abort previous request\n let wsConnected = false;\n try {\n ws = new WebSocket(`${url}/sdapi/v1/browser/files`);\n wsConnected = await wsConnect(ws);\n } catch (err) {\n log('gallery: ws connect error', err);\n return;\n }\n log(`gallery: connected=${wsConnected} state=${ws?.readyState} url=${ws?.url}`);\n currentGalleryFolder = evt.target.name;\n if (!wsConnected) {\n await fetchFilesHT(evt, controller); // fallback to http\n return;\n }\n updateStatusLine(['Folder', evt.target.name]);\n const t0 = performance.now();\n let numFiles = 0;\n let t1 = performance.now();\n let fragment = document.createDocumentFragment();\n\n ws.onmessage = (event) => {\n t1 = performance.now();\n const data = decodeURI(event.data).split('##F##');\n if (data[0] === '#END#') {\n ws.close();\n } else {\n const fileName = data[1];\n const ext = fileName.split('.').pop().toLowerCase();\n if (SUPPORTED_EXTENSIONS.includes(ext)) {\n const file = new GalleryFile(data[0], fileName, controller.signal);\n numFiles++;\n fragment.appendChild(file);\n if (numFiles % fragmentSize === 0) {\n updateStatusLine(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], ['Status', 'in-progress'], ['Time', `${Math.floor(t1 - t0).toLocaleString()}ms`]);\n el.files.appendChild(fragment);\n fragment = document.createDocumentFragment();\n }\n }\n }\n };\n ws.onclose = (event) => {\n if (controller.signal.aborted) return;\n el.files.appendChild(fragment);\n // gallerySort();\n log(`gallery: folder=${evt.target.name} num=${numFiles} method=ws time=${Math.floor(t1 - t0)}ms`);\n updateStatusLine(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], ['Time', `${Math.floor(t1 - t0).toLocaleString()}ms`]);\n pb.start(numFiles);\n addSeparators();\n refreshGallerySelection();\n thumbCacheCleanup(evt.target.name, numFiles, controller);\n };\n ws.onerror = (event) => {\n log('gallery ws error', event);\n };\n ws.send(encodeURI(evt.target.name));\n}\n\nasync function updateFolders() {\n // if (el.folders.children.length > 0) return;\n const res = await authFetch(`${window.api}/browser/folders`);\n if (!res || res.status !== 200) return;\n url = res.url.split('/sdapi')[0].replace('http', 'ws'); // update global url as ws need fqdn\n const folders = await res.json();\n el.folders.innerHTML = '';\n for (const folder of folders) {\n const f = new GalleryFolder(folder);\n el.folders.appendChild(f);\n }\n}\n\nasync function monitorGalleries() {\n async function galleryMutation(mutations) {\n const galleries = mutations.filter((m) => m.target?.classList?.contains('preview'));\n for (const gallery of galleries) {\n const links = gallery.target.querySelectorAll('a');\n for (const link of links) {\n const href = link.getAttribute('href');\n if (!href) continue;\n const fn = href.split('/').pop().split('\\\\').pop();\n link.setAttribute('download', fn);\n }\n }\n }\n\n const galleryElements = gradioApp().querySelectorAll('.gradio-gallery');\n for (const gallery of galleryElements) {\n const galleryObserver = new MutationObserver(galleryMutation);\n galleryObserver.observe(gallery, { childList: true, subtree: true, attributes: true });\n }\n}\n\nasync function setOverlayAnimation() {\n const busyAnimation = document.createElement('style');\n\n // eslint-disable-next-line @stylistic/max-len\n busyAnimation.textContent = '.idbBusyAnim{width:16px;height:16px;border-radius:50%;display:block;margin:40px;position:relative;background:#aa3d00;color:#fff;box-shadow:-24px 0,24px 0;box-sizing:border-box;animation:2s ease-in-out infinite overlayRotation}@keyframes overlayRotation{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}';\n document.head.append(busyAnimation);\n}\n\nasync function initGalleryAutoRefresh() {\n const isModern = opts.theme_type?.toLowerCase() === 'modern';\n let galleryTab = isModern ? document.getElementById('gallery_tabitem') : document.getElementById('tab_gallery');\n let timeout = 0;\n while (!galleryTab && timeout++ < 60) {\n await new Promise((resolve) => { setTimeout(resolve, 2500); });\n galleryTab = isModern ? document.getElementById('gallery_tabitem') : document.getElementById('tab_gallery');\n }\n if (!galleryTab) {\n error('Gallery: timeout');\n return;\n }\n const displayNoneRegEx = /display:\\s*none/;\n async function galleryAutoRefresh(mutations) {\n if (!opts.browser_gallery_autoupdate) return;\n for (const mutation of mutations) {\n switch (mutation.attributeName) {\n case 'class':\n if (mutation.oldValue.includes('hidden') && !mutation.target.classList.contains('hidden')) {\n await updateFolders();\n GalleryFolder.getActive()?.click();\n }\n break;\n case 'style':\n if (displayNoneRegEx.test(mutation.oldValue) && !displayNoneRegEx.test(mutation.target.style.display)) {\n await updateFolders();\n GalleryFolder.getActive()?.click();\n }\n break;\n default:\n break;\n }\n }\n }\n const galleryVisObserver = new MutationObserver(galleryAutoRefresh);\n galleryVisObserver.observe(galleryTab, { attributeFilter: ['class', 'style'], attributeOldValue: true });\n}\n\nasync function overlayDelete(evt) {\n const res = await authFetch(`${window.api}/delete-image?file=${encodeURIComponent(currentImage)}`, { method: 'DELETE' });\n evt.stopPropagation();\n if (!res || res.status !== 200) {\n error('galleryDelete', { file: currentImage, status: res?.status, statusText: res?.statusText });\n return;\n }\n const data = await res.json();\n log('galleryDelete', data);\n GalleryFolder.getActive()?.click();\n}\n\nasync function overlayDownload(evt) {\n log('galleryDownload', currentImage);\n const link = document.createElement('a');\n link.href = `/file=${encodeURIComponent(currentImage)}`;\n link.download = currentName;\n document.body.appendChild(link);\n link.click();\n document.body.removeChild(link);\n evt.stopPropagation();\n}\n\nasync function overlayInfo(evt) {\n evt.stopPropagation();\n const tgt = document.getElementById('html_info_formatted_gallery');\n if (!tgt) return;\n const res = await authFetch(`${window.api}/png-info?file=${encodeURI(currentImage)}`);\n if (!res || res.status !== 200) return;\n const data = await res.json();\n log('galleryInfo res', data);\n const prompt = data?.parameters?.Prompt || '';\n const negative = data?.parameters?.Negative || data?.parameters?.['Negative prompt'] || '';\n const raw = data?.info || '';\n const params = data?.parameters || {};\n delete params.Prompt;\n delete params.Negative;\n delete params['Negative prompt'];\n const paramsFormatted = Object.entries(params).map(([key, value]) => `${key}: ${value}`).join(' | ');\n tgt.innerHTML = `\n
    File: ${currentImage}
    \n
    Prompt: ${prompt}
    \n
    Negative: ${negative}
    \n
    ${paramsFormatted}
    \n
    Raw:
    ${raw}
    \n `;\n const img = document.querySelector('#gallery_gallery img');\n if (img) img.src = `/file=${encodeURIComponent(currentImage)}?t=${Date.now()}`; // Force refresh in case info endpoint is faster than cache update\n const status = document.querySelector('#html_log_gallery p');\n if (status) status.innerText = currentTitle;\n}\n\nasync function createOverlay() {\n if (el.overlay) return;\n el.overlay = document.createElement('div');\n el.overlay.className = 'gallery-overlay';\n const btnDownload = document.createElement('span');\n btnDownload.innerHTML = '\\udb85\\udc64';\n btnDownload.title = 'Download image';\n btnDownload.style.cursor = 'pointer';\n btnDownload.addEventListener('click', overlayDownload);\n const btnDelete = document.createElement('span');\n btnDelete.innerHTML = '\\uf05c';\n btnDelete.title = 'Delete image';\n btnDelete.style.cursor = 'pointer';\n btnDelete.addEventListener('click', overlayDelete);\n const btnInfo = document.createElement('span');\n btnInfo.innerHTML = '\\uf05a';\n btnInfo.title = 'Image metadata';\n btnInfo.style.cursor = 'pointer';\n btnInfo.addEventListener('click', overlayInfo);\n el.overlay.append(btnInfo, btnDelete, btnDownload);\n}\n\nasync function blockQueueUntilReady() {\n // Add block to maintenanceQueue until cache is ready\n maintenanceQueue.enqueue({\n signal: new AbortController().signal, // Use standalone AbortSignal that can't be aborted\n callback: async () => {\n let timeout = 0;\n while (!idbIsReady() && timeout++ < 60) {\n await new Promise((resolve) => { setTimeout(resolve, 1000); });\n }\n if (!idbIsReady()) {\n throw new Error('Timed out waiting for thumbnail cache');\n }\n },\n });\n}\n\nexport async function initGallery() { // triggered on gradio change to monitor when ui gets sufficiently constructed\n const t0 = performance.now();\n el.folders = gradioApp().getElementById('tab-gallery-folders');\n el.files = gradioApp().getElementById('tab-gallery-files');\n el.status = gradioApp().getElementById('tab-gallery-status');\n el.search = gradioApp().querySelector('#tab-gallery-search textarea');\n el.size = document.getElementById('tab-gallery-thumb-size');\n if (!el.folders || !el.files || !el.status || !el.search) {\n error('initGallery', 'Missing gallery elements');\n return;\n }\n\n if (el.size) {\n el.size.value = opts.extra_networks_card_size;\n el.size.addEventListener('input', updateGalleryStyles);\n }\n blockQueueUntilReady(); // Run first\n createOverlay();\n updateGalleryStyles();\n injectGalleryStatusCSS();\n setOverlayAnimation();\n\n const progress = gradioApp().getElementById('tab-gallery-progress');\n if (progress) pb.attachTo(progress);\n else log('initGallery', 'Failed to attach loading progress bar');\n\n el.search.addEventListener('input', gallerySearch);\n el.btnSend = gradioApp().getElementById('tab-gallery-send-image');\n document.getElementById('tab-gallery-files').style.height = opts.logmonitor_show ? '75vh' : '85vh';\n\n monitorGalleries();\n updateFolders();\n initGalleryAutoRefresh();\n [\n 'browser_folders',\n 'outdir_samples',\n 'outdir_txt2img_samples',\n 'outdir_img2img_samples',\n 'outdir_control_samples',\n 'outdir_extras_samples',\n 'outdir_save',\n 'outdir_video',\n 'outdir_init_images',\n 'outdir_grids',\n 'outdir_txt2img_grids',\n 'outdir_img2img_grids',\n 'outdir_control_grids',\n ].forEach((op) => { monitorOption(op, updateFolders); });\n const t1 = performance.now();\n log('initGallery', Math.round(t1 - t0));\n timer('initGallery', t1 - t0);\n}\n\n// register on startup\n\ncustomElements.define('gallery-folder', GalleryFolder);\ncustomElements.define('gallery-file', GalleryFile);\n", "import exifr from 'exifr';\nimport Panzoom from 'panzoom';\nimport { log, debug } from './logger';\nimport { gradioApp, onAfterUiUpdate } from './script';\nimport { getENActiveTab } from './extraNetworks';\nimport { all_gallery_buttons, selected_gallery_button } from './ui';\nimport { timer } from './timers';\n\n// A full size 'lightbox' preview modal shown when left clicking on gallery previews\nlet previewDrag = false;\nlet modalPreviewZone;\nlet previewInstance;\n\nfunction cycleImageFit() {\n const root = document.documentElement;\n const current = getComputedStyle(root).getPropertyValue('--sd-image-fit').trim();\n let next = 'contain';\n if (current === 'contain') next = 'cover';\n else if (current === 'cover') next = 'fill';\n else if (current === 'fill') next = 'scale-down';\n else if (current === 'scale-down') next = 'none';\n root.style.setProperty('--sd-image-fit', next);\n log('cycleImageFit', current, next);\n}\n\nwindow.cycleImageFit = cycleImageFit;\n\nfunction isInViewport(element) {\n const rect = element.getBoundingClientRect();\n return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);\n}\n\nfunction closeModal(evt, force = false) {\n if (force) gradioApp().getElementById('lightboxModal').style.display = 'none';\n if (previewDrag) return;\n if (evt?.button !== 0) return;\n gradioApp().getElementById('lightboxModal').style.display = 'none';\n let thumbnails = Array.from(gradioApp().querySelectorAll('.thumbnails .thumbnail-item'));\n thumbnails = thumbnails.filter((el) => el.checkVisibility());\n if (thumbnails.length === 0) return;\n thumbnails[0].focus();\n}\n\nfunction modalImageSwitch(offset) {\n const negmod = (n, m) => ((n % m) + m) % m;\n const galleryButtons = all_gallery_buttons();\n if (galleryButtons.length > 1) {\n const currentButton = selected_gallery_button();\n let result = -1;\n galleryButtons.forEach((v, i) => {\n if (v === currentButton) result = i;\n });\n if (result !== -1) {\n const nextButton = galleryButtons[negmod((result + offset), galleryButtons.length)];\n nextButton.click();\n const modalImage = gradioApp().getElementById('modalImage');\n const modal = gradioApp().getElementById('lightboxModal');\n modalImage.src = nextButton.children[0].src;\n if (modalImage.style.display === 'none') modal.style.setProperty('background-image', `url(${modalImage.src})`);\n return;\n }\n }\n\n const galleryFilesContainer = gradioApp().getElementById('tab-gallery-files');\n if (!galleryFilesContainer || !galleryFilesContainer.offsetParent) return;\n const gallerySelection = window.getGallerySelection();\n if (!gallerySelection.files.length || gallerySelection.files.length <= 1) return;\n const baseIndex = gallerySelection.index >= 0 ? gallerySelection.index : 0;\n const nextIndex = negmod((baseIndex + offset), gallerySelection.files.length);\n window.setGallerySelection(nextIndex, { send: true });\n const modalImage = gradioApp().getElementById('modalImage');\n const modal = gradioApp().getElementById('lightboxModal');\n const directSrc = window.getGallerySelectedUrl();\n if (modalImage && modal && directSrc) {\n modalImage.src = directSrc;\n if (modalImage.style.display === 'none') modal.style.setProperty('background-image', `url(${directSrc})`);\n }\n}\n\nfunction modalSaveImage(event?: any) {\n const tabName = getENActiveTab();\n const saveBtn = gradioApp().getElementById(`save_${tabName}`);\n log('modalSaveImage', tabName, saveBtn);\n if (saveBtn) saveBtn.click();\n modalImageSwitch(0);\n}\n\nfunction modalKeyHandler(event) {\n log('modalKeyHandler', event.key);\n switch (event.key) {\n case 's':\n modalSaveImage();\n break;\n case 'ArrowLeft':\n modalImageSwitch(-1);\n break;\n case 'ArrowRight':\n modalImageSwitch(1);\n break;\n case 'Escape':\n closeModal(null, true);\n break;\n }\n event.stopPropagation();\n}\n\nfunction decodeBytes(bytes: Uint8Array): string {\n if (!bytes || bytes.length < 8) return '';\n const prefix = new TextDecoder('ascii').decode(bytes.slice(0, 8));\n const data = bytes.slice(8);\n if (prefix.startsWith('ASCII')) return new TextDecoder('ascii').decode(data).replace(/\\0+$/, '');\n if (prefix.startsWith('UNICODE')) return new TextDecoder('utf-16be').decode(data).replace(/\\0+$/, '');\n if (prefix.startsWith('JIS')) return new TextDecoder('shift-jis').decode(data).replace(/\\0+$/, '');\n return new TextDecoder().decode(bytes).replace(/\\0+$/, '');\n}\n\nexport async function getExif(el) {\n let exif: any = '';\n try {\n exif = await exifr.parse(el, { userComment: true });\n } catch (e) {\n log('getExif', el, e);\n return exif;\n }\n // let html = `Image ${el.src} Size ${el.naturalWidth}x${el.naturalHeight}
    `;\n let html = '';\n let params;\n if (!exif) {\n log('getExif', 'exif is none');\n return html;\n }\n if (exif.parameters) params = exif.parameters;\n else if (exif.userComment) params = decodeBytes(exif.userComment);\n else params = '';\n // debug('getExif', params);\n if (params.length > 0) html += `Prompt ${params || ''}
    `;\n html = html.replace('Negative prompt:', '
    Negative');\n html = html.replace('Steps:', '
    Params Steps:');\n html = html.replaceAll('\\n', '
    ');\n html = html.replaceAll('

    ', '
    ');\n return html;\n}\n\nasync function displayExif(el) {\n const modalExif = gradioApp().getElementById('modalExif');\n const html = await getExif(el);\n modalExif.innerHTML = html;\n}\n\nfunction showModal(event) {\n const source = event.target || event.srcElement;\n const modalImage = gradioApp().getElementById('modalImage');\n const lb = gradioApp().getElementById('lightboxModal');\n lb.ownerSVGElement = modalImage;\n modalImage.onload = () => {\n previewInstance.moveTo(0, 0);\n modalPreviewZone.focus();\n if (opts.viewer_show_metadata) displayExif(modalImage);\n };\n modalImage.src = source.src;\n if (modalImage.style.display === 'none') lb.style.setProperty('background-image', `url(${source.src})`);\n lb.style.display = 'flex';\n lb.onkeydown = modalKeyHandler;\n event.stopPropagation();\n}\n\nfunction modalDownloadImage() {\n const link = document.createElement('a');\n link.style.display = 'none';\n link.href = gradioApp().getElementById('modalImage').src;\n link.download = 'image';\n document.body.appendChild(link);\n link.click();\n setTimeout(() => {\n URL.revokeObjectURL(link.href);\n link.parentNode.removeChild(link);\n }, 0);\n}\n\nfunction modalZoomSet(modalImage, enable) {\n localStorage.setItem('modalZoom', enable ? 'yes' : 'no');\n if (modalImage) modalImage.classList.toggle('modalImageFullscreen', !!enable);\n}\n\nfunction setupImageForLightbox(image) {\n if (image.dataset.modded) return;\n image.dataset.modded = 'true';\n image.style.cursor = 'pointer';\n image.style.userSelect = 'none';\n}\n\nfunction modalZoomToggle(event) {\n const modalImage = gradioApp().getElementById('modalImage');\n modalZoomSet(modalImage, !modalImage.classList.contains('modalImageFullscreen'));\n event.stopPropagation();\n modalImageSwitch(0);\n}\n\nfunction modalTileToggle(event) {\n const modalImage = gradioApp().getElementById('modalImage');\n const modal = gradioApp().getElementById('lightboxModal');\n const isTiling = modalImage.style.display === 'none';\n if (isTiling) {\n modalImage.style.display = 'block';\n modal.style.setProperty('background-image', 'none');\n } else {\n modalImage.style.display = 'none';\n modal.style.setProperty('background-image', `url(${modalImage.src})`);\n }\n event.stopPropagation();\n modalImageSwitch(0);\n}\n\nfunction modalResetInstance(event) {\n const modalImage = document.getElementById('modalImage');\n previewInstance.dispose();\n previewInstance = Panzoom(modalImage, { zoomSpeed: 0.05, minZoom: 0.1, maxZoom: 5.0, filterKey: (/* e, dx, dy, dz */) => true });\n event.stopPropagation();\n modalImageSwitch(0);\n}\n\nfunction modalToggleParams(event) {\n const modalExif = gradioApp().getElementById('modalExif');\n if (modalExif.style.display === 'none' || modalExif.style.display === '') {\n modalExif.style.display = 'block';\n } else {\n modalExif.style.display = 'none';\n }\n event.stopPropagation();\n modalImageSwitch(0);\n}\n\nfunction galleryClickEventHandler(event) {\n if (event.button !== 0) return;\n if (event.target.nodeName === 'IMG' && !event.target.parentNode.classList.contains('thumbnail-item')) {\n const initialZoom = (localStorage.getItem('modalZoom') || true) === 'yes';\n modalZoomSet(gradioApp().getElementById('modalImage'), initialZoom);\n event.preventDefault();\n showModal(event);\n }\n}\n\nasync function bindImageViewer() {\n // Each tab has its own gradio-gallery\n const galleryPreviews = gradioApp().querySelectorAll('.gradio-gallery > div.preview');\n for (const galleryPreview of galleryPreviews) {\n if (!galleryPreview.hasAttribute('data-listener')) galleryPreview.addEventListener('click', galleryClickEventHandler, true);\n galleryPreview.setAttribute('data-listener', 'true');\n galleryPreview.querySelectorAll('img').forEach(setupImageForLightbox);\n }\n}\n\nexport async function initImageViewer() {\n const t0 = performance.now();\n // main elements\n const modal = document.createElement('div');\n modal.id = 'lightboxModal';\n\n modalPreviewZone = document.createElement('div');\n modalPreviewZone.className = 'lightboxModalPreviewZone';\n\n const modalImage = document.createElement('img');\n modalImage.id = 'modalImage';\n modalPreviewZone.appendChild(modalImage);\n previewInstance = Panzoom(modalImage, { zoomSpeed: 0.05, minZoom: 0.1, maxZoom: 5.0, filterKey: (/* e, dx, dy, dz */) => true });\n\n // toolbar\n const modalZoom = document.createElement('span');\n modalZoom.id = 'modal_zoom';\n modalZoom.className = 'cursor';\n modalZoom.innerHTML = '\\uf531';\n modalZoom.title = 'Toggle zoomed view';\n modalZoom.addEventListener('click', modalZoomToggle, true);\n\n const modalReset = document.createElement('span');\n modalReset.id = 'modal_reset';\n modalReset.className = 'cursor';\n modalReset.innerHTML = '\\uf532';\n modalReset.title = 'Reset zoomed view';\n modalReset.addEventListener('click', modalResetInstance, true);\n\n const modalTile = document.createElement('span');\n modalTile.id = 'modal_tile';\n modalTile.className = 'cursor';\n modalTile.innerHTML = '\\udb81\\udd70';\n modalTile.title = 'Preview tiling';\n modalTile.addEventListener('click', modalTileToggle, true);\n\n const modalSave = document.createElement('span');\n modalSave.id = 'modal_save';\n modalSave.className = 'cursor';\n modalSave.innerHTML = '\\udb80\\udd93';\n modalSave.title = 'Save Image';\n modalSave.addEventListener('click', modalSaveImage, true);\n\n const modalDownload = document.createElement('span');\n modalDownload.id = 'modal_download';\n modalDownload.className = 'cursor';\n modalDownload.innerHTML = '\\udb85\\udc62';\n modalDownload.title = 'Download Image';\n modalDownload.addEventListener('click', modalDownloadImage, true);\n\n const modalClose = document.createElement('span');\n modalClose.id = 'modal_close';\n modalClose.className = 'cursor';\n modalClose.innerHTML = '\\udb80\\udd57';\n modalClose.title = 'Close';\n modalClose.addEventListener('click', (evt) => closeModal(evt, true), true);\n\n const modalToggleParamsBtn = document.createElement('span');\n modalToggleParamsBtn.id = 'modal_toggle_params';\n modalToggleParamsBtn.className = 'cursor';\n modalToggleParamsBtn.innerHTML = '\\uf05a';\n modalToggleParamsBtn.title = 'Toggle Parameters';\n modalToggleParamsBtn.addEventListener('click', modalToggleParams, true);\n\n // exif\n const modalExif = document.createElement('div');\n modalExif.id = 'modalExif';\n modalExif.style = 'position: absolute; bottom: 0px; width: 100%; background-color: rgba(0, 0, 0, 0.5); color: var(--neutral-300); padding: 1em; font-size: small; line-height: 1.2em; z-index: 1; display: none;';\n\n // handlers\n modalPreviewZone.addEventListener('mousedown', () => { previewDrag = false; });\n modalPreviewZone.addEventListener('touchstart', () => { previewDrag = false; }, { passive: true });\n modalPreviewZone.addEventListener('mousemove', () => { previewDrag = true; });\n modalPreviewZone.addEventListener('touchmove', () => { previewDrag = true; }, { passive: true });\n modalPreviewZone.addEventListener('scroll', () => { previewDrag = true; });\n modalPreviewZone.addEventListener('mouseup', (evt) => closeModal(evt));\n modalPreviewZone.addEventListener('touchend', (evt) => closeModal(evt));\n\n const modalPrev = document.createElement('a');\n modalPrev.className = 'modalPrev';\n modalPrev.innerHTML = '❮';\n modalPrev.addEventListener('click', () => modalImageSwitch(-1), true);\n // modalPrev.addEventListener('keydown', modalKeyHandler, true);\n\n const modalNext = document.createElement('a');\n modalNext.className = 'modalNext';\n modalNext.innerHTML = '❯';\n modalNext.addEventListener('click', () => modalImageSwitch(1), true);\n // modalNext.addEventListener('keydown', modalKeyHandler, true);\n\n const modalControls = document.createElement('div');\n modalControls.className = 'modalControls gradio-container';\n\n // build interface\n modal.appendChild(modalPrev);\n modal.appendChild(modalPreviewZone);\n modal.appendChild(modalNext);\n modal.append(modalControls);\n modalControls.appendChild(modalZoom);\n modalControls.appendChild(modalReset);\n modalControls.appendChild(modalTile);\n modalControls.appendChild(modalSave);\n modalControls.appendChild(modalDownload);\n modalControls.appendChild(modalToggleParamsBtn);\n modalControls.appendChild(modalClose);\n modal.append(modalExif);\n\n gradioApp().appendChild(modal);\n const t1 = performance.now();\n log('initImageViewer', Math.round(t1 - t0));\n timer('initImageViewer', t1 - t0);\n}\n\nonAfterUiUpdate(bindImageViewer);\n", "import { log } from './logger';\n\n/*\n * Extra-networks completion for SD.Next prompt textareas.\n *\n * Companion to autocomplete.js: exposes sorted indices for LoRAs, embeddings, and wildcards,\n * each backed by an existing enumeration endpoint. Dispatch and insertion are driven from\n * autocomplete.js via the mode returned by getCurrentWord().\n */\n\ninterface XnItem {\n name: string;\n display?: string;\n}\n\ninterface SearchItem {\n name: string;\n display: string;\n}\n\ntype SearchResult = SearchItem & { kind: 'lora' | 'embed' | 'wildcard' };\n\n/** Binary search for the first item where item.name >= query. */\nexport function lowerBound(items: { name: string }[], query: string): number {\n let lo = 0;\n let hi = items.length;\n while (lo < hi) {\n const mid = (lo + hi) >>> 1;\n if (items[mid].name < query) lo = mid + 1;\n else hi = mid;\n }\n return lo;\n}\n\ninterface XnEngine {\n lora: XnIndex;\n embed: XnIndex;\n wildcard: XnIndex;\n fetchJson(path: string): Promise;\n loadAll(): Promise;\n searchLoras(prefix: string, limit?: number): SearchResult[];\n searchEmbeddings(prefix: string, limit?: number): SearchResult[];\n searchWildcards(prefix: string, limit?: number): SearchResult[];\n}\n\n// -- Indices --\n\nclass XnIndex {\n items: SearchItem[];\n\n constructor(items: XnItem[]) {\n // items: [{ name, display }]. Sorted in-place by lowercase name.\n this.items = items.map(({ name, display }) => ({\n name: String(name).toLowerCase(),\n display: display ?? name,\n }));\n this.items.sort((a, b) => a.name.localeCompare(b.name));\n }\n\n search(prefix: string, limit = 20): SearchItem[] {\n const query = String(prefix).toLowerCase();\n // Empty query returns the first `limit` items so `= 3) {\n for (let i = 0; i < this.items.length && matches.length < limit; i++) {\n if (this.items[i].name.includes(query)) matches.push(this.items[i]);\n }\n }\n return matches.slice(0, limit);\n }\n}\n\n// -- Engine --\n\nexport const xnEngine: XnEngine = {\n lora: new XnIndex([]),\n embed: new XnIndex([]),\n wildcard: new XnIndex([]),\n\n async fetchJson(path) {\n try {\n const resp = await fetch(`${window.api}${path}`, { credentials: 'include' });\n if (!resp.ok) throw new Error(`${resp.status}`);\n return await resp.json();\n } catch (e) {\n log('autoComplete', { xnFetchFailed: path, error: String(e) });\n return null;\n }\n },\n\n async loadAll() {\n // LoRAs: [{name, alias, path, metadata}, ...]\n const loraData = await this.fetchJson('/loras');\n if (Array.isArray(loraData)) {\n const items: XnItem[] = [];\n for (const lo of loraData) {\n if (typeof lo === 'object' && lo && 'name' in lo && typeof lo.name === 'string') items.push({ name: lo.name });\n if (typeof lo === 'object' && lo && 'alias' in lo && typeof lo.alias === 'string' && lo.alias !== (lo as { name?: string }).name) items.push({ name: lo.alias });\n }\n this.lora = new XnIndex(items);\n }\n // Embeddings: {loaded: [...], skipped: [...]}\n const embData = await this.fetchJson('/embeddings') as Record | null;\n if (embData && typeof embData === 'object') {\n const loaded = Array.isArray(embData.loaded) ? embData.loaded : [];\n this.embed = new XnIndex(loaded.map((name) => ({ name: String(name) })));\n }\n // Wildcards: [{name}, ...]\n const wcData = await this.fetchJson('/wildcards');\n if (Array.isArray(wcData)) {\n this.wildcard = new XnIndex(\n wcData\n .filter((w) => typeof w === 'object' && w && 'name' in w && typeof w.name === 'string')\n .map((w) => ({ name: w.name })),\n );\n }\n log('autoComplete', {\n xnLoaded: true,\n lora: this.lora.items.length,\n embed: this.embed.items.length,\n wildcard: this.wildcard.items.length,\n });\n },\n\n searchLoras(prefix, limit = 20) {\n return this.lora.search(prefix, limit).map((item) => ({ ...item, kind: 'lora' as const }));\n },\n\n searchEmbeddings(prefix, limit = 20) {\n return this.embed.search(prefix, limit).map((item) => ({ ...item, kind: 'embed' as const }));\n },\n\n searchWildcards(prefix, limit = 20) {\n return this.wildcard.search(prefix, limit).map((item) => ({ ...item, kind: 'wildcard' as const }));\n },\n};\n", "import { xnEngine, lowerBound } from './autocomplete_xn';\nimport { log } from './logger';\nimport { gradioApp, onAfterUiUpdate, onOptionsChanged, executeCallbacks, optionsChangedCallbacks } from './script';\nimport { timer } from './timers';\nimport { updateInput } from './ui';\n\n/*\n * Tag autocomplete for SD.Next prompt textareas.\n *\n * Ported from Enso's CodeMirror-based autocomplete (autocomplete.ts).\n * Uses binary search on sorted tag arrays for O(log n) prefix lookup,\n * with substring fallback for 4+ char queries.\n */\n\n// -- Category colors (unified 14-category scheme) --\n\nconst CATEGORY_COLORS = {\n 0: '#0075f8', // general\n 1: '#cc0000', // artist\n 2: '#ff4500', // studio\n 3: '#9900ff', // copyright\n 4: '#00ab2c', // character\n 5: '#ed5d1f', // species\n 6: '#8a66ff', // genre\n 7: '#00cccc', // medium\n 8: '#6b7280', // meta\n 9: '#228b22', // lore\n 10: '#e67e22', // lens\n 11: '#f1c40f', // lighting\n 12: '#1abc9c', // composition\n 13: '#e84393', // color\n};\n\nconst CATEGORY_NAMES = {\n 0: 'general',\n 1: 'artist',\n 2: 'studio',\n 3: 'copyright',\n 4: 'character',\n 5: 'species',\n 6: 'genre',\n 7: 'medium',\n 8: 'meta',\n 9: 'lore',\n 10: 'lens',\n 11: 'lighting',\n 12: 'composition',\n 13: 'color',\n};\n\n// Glyph + color per result kind. Renders in place of the category dot for non-tag results.\nconst KIND_GLYPHS = {\n tag: { glyph: '\u25CF', color: null }, // color pulled from tag category\n lora: { glyph: '\u25C6', color: '#8a66ff' },\n embed: { glyph: '\u25B2', color: '#1abc9c' },\n wildcard: { glyph: '\u2605', color: '#f1c40f' },\n};\n\nlet active = false;\n\ninterface TagResult {\n name: string;\n display: string;\n category: number | string;\n count: number;\n aliases?: string[];\n matchedVia?: 'alias' | 'translation';\n matchedAlias?: string;\n matchedTerm?: string;\n}\n\n// -- Utilities (ported from Enso) --\n\n/** Format post count as abbreviated string. */\nfunction formatCount(count: number): string {\n if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;\n if (count >= 1_000) return `${Math.round(count / 1_000)}k`;\n return String(count);\n}\n\n/**\n * Estimate viewport Y of the bottom of the caret line using a persistent\n * offscreen mirror div. Styles and width are re-read from the textarea on\n * every call so resized textareas are handled correctly.\n */\nlet caretMirror: HTMLDivElement | null = null;\nlet caretMarker: HTMLSpanElement | null = null;\nconst MIRROR_PROPS = ['fontFamily', 'fontSize', 'fontWeight', 'fontStyle',\n 'lineHeight', 'letterSpacing', 'wordSpacing', 'textTransform',\n 'padding', 'border', 'boxSizing'];\n\nfunction caretViewportY(textarea: HTMLTextAreaElement): number {\n if (!caretMirror) {\n caretMirror = document.createElement('div');\n caretMirror.className = 'autocomplete-mirror';\n caretMirror.style.whiteSpace = 'pre-wrap';\n caretMirror.style.wordWrap = 'break-word';\n caretMirror.style.position = 'absolute';\n caretMirror.style.left = '-9999px';\n caretMirror.style.overflow = 'hidden';\n caretMarker = document.createElement('span');\n caretMarker.textContent = '\\u200b';\n document.body.appendChild(caretMirror);\n }\n const cs = getComputedStyle(textarea);\n for (const p of MIRROR_PROPS) caretMirror.style[p] = cs[p];\n caretMirror.style.width = `${textarea.offsetWidth}px`;\n caretMirror.textContent = textarea.value.substring(0, textarea.selectionStart);\n caretMirror.appendChild(caretMarker);\n const offset = caretMarker.offsetTop + caretMarker.offsetHeight;\n return textarea.getBoundingClientRect().top + offset - textarea.scrollTop;\n}\n\n// -- TagIndex --\n\nclass TagIndex {\n categories: Record;\n tags: TagResult[];\n aliasEntries: { name: string; display: string; tag: TagResult }[];\n translations: Map;\n tagByName: Map;\n translationEntries: { name: string; foreign: string; canonical: string }[];\n\n constructor(data: any) {\n this.categories = data.categories || {};\n // Tuples are [name, catId, count] or [name, catId, count, aliases]. Default `aliases = []`\n // keeps legacy 3-tuple dictionaries working unchanged.\n this.tags = data.tags.map(([name, category, count, aliases = []]) => ({\n name: name.toLowerCase(),\n display: name,\n category,\n count,\n aliases,\n }));\n this.tags.sort((a, b) => a.name.localeCompare(b.name));\n // Alias index parallel to this.tags. Each entry has .name so lowerBound works on both.\n this.aliasEntries = [];\n for (const tag of this.tags) {\n if (!tag.aliases || tag.aliases.length === 0) continue;\n for (const alias of tag.aliases) {\n this.aliasEntries.push({ name: alias.toLowerCase(), display: alias, tag });\n }\n }\n this.aliasEntries.sort((a, b) => a.name.localeCompare(b.name));\n // Optional translations companion: foreign_term -> canonical_tag_name.\n // tagByName is keyed on canonical lowercased name for O(1) resolution from a translation hit.\n this.translations = new Map();\n this.tagByName = new Map(this.tags.map((t) => [t.name, t]));\n if (data.translations && typeof data.translations === 'object') {\n for (const [foreign, canonical] of Object.entries(data.translations)) {\n if (typeof foreign !== 'string' || typeof canonical !== 'string') continue;\n this.translations.set(foreign.toLowerCase(), { canonical: canonical.toLowerCase(), foreign });\n }\n }\n // Sorted translation keys for prefix+substring scan via lowerBound.\n this.translationEntries = [...this.translations.entries()]\n .map(([foreignLower, { canonical, foreign }]) => ({ name: foreignLower, foreign, canonical }))\n .sort((a, b) => a.name.localeCompare(b.name));\n }\n\n /** Prefix search with binary search across canonical names and aliases. Returns matches sorted by count descending. */\n search(prefix: string, limit = 20): TagResult[] {\n const query = prefix.toLowerCase().replace(/ /g, '_');\n if (!query) return [];\n // Canonical prefix matches\n const matches = [];\n const start = lowerBound(this.tags, query);\n for (let i = start; i < this.tags.length && matches.length < limit * 5; i++) {\n if (!this.tags[i].name.startsWith(query)) break;\n matches.push(this.tags[i]);\n }\n // Alias prefix matches. Annotate so render can show \"canonical (alias)\".\n const aliasStart = lowerBound(this.aliasEntries, query);\n for (let i = aliasStart; i < this.aliasEntries.length && matches.length < limit * 10; i++) {\n const entry = this.aliasEntries[i];\n if (!entry.name.startsWith(query)) break;\n matches.push({ ...entry.tag, matchedVia: 'alias', matchedAlias: entry.display });\n }\n // Substring fallback (canonical + aliases) for 4+ char queries when prefix matching returned nothing.\n if (matches.length === 0 && query.length >= 4) {\n for (let i = 0; i < this.tags.length && matches.length < limit * 5; i++) {\n if (this.tags[i].name.includes(query)) matches.push(this.tags[i]);\n }\n for (let i = 0; i < this.aliasEntries.length && matches.length < limit * 10; i++) {\n const entry = this.aliasEntries[i];\n if (entry.name.includes(query)) matches.push({ ...entry.tag, matchedVia: 'alias', matchedAlias: entry.display });\n }\n }\n // Translation lookup. Prefix scan over foreign terms, resolving to canonical tags when present.\n if (this.translationEntries.length > 0) {\n const tStart = lowerBound(this.translationEntries, query);\n for (let i = tStart; i < this.translationEntries.length && matches.length < limit * 10; i++) {\n const entry = this.translationEntries[i];\n if (!entry.name.startsWith(query)) break;\n const canonicalTag = this.tagByName.get(entry.canonical);\n if (canonicalTag) matches.push({ ...canonicalTag, matchedVia: 'translation', matchedTerm: entry.foreign });\n }\n // Substring fallback over translation keys (CJK/short foreign terms benefit from 2-char threshold)\n if (query.length >= 2) {\n for (let i = 0; i < this.translationEntries.length && matches.length < limit * 10; i++) {\n const entry = this.translationEntries[i];\n if (entry.name.includes(query) && !entry.name.startsWith(query)) {\n const canonicalTag = this.tagByName.get(entry.canonical);\n if (canonicalTag) matches.push({ ...canonicalTag, matchedVia: 'translation', matchedTerm: entry.foreign });\n }\n }\n }\n }\n // Dedupe by canonical name; prefer canonical (no matchedVia) over alias/translation matches.\n const seen = new Map();\n for (const tag of matches) {\n const existing = seen.get(tag.name);\n if (!existing || (existing.matchedVia && !tag.matchedVia)) seen.set(tag.name, tag);\n }\n const result = [...seen.values()];\n result.sort((a, b) => b.count - a.count);\n return result.slice(0, limit);\n }\n}\n\n// -- Engine --\n\nconst engine = {\n indices: new Map(), // name -> TagIndex\n categoryColors: { ...CATEGORY_COLORS },\n categoryNames: { ...CATEGORY_NAMES },\n\n async loadEnabled() {\n const enabled = window.opts?.autocomplete_enabled || [];\n active = window.opts?.autocomplete_active || false;\n if (!active) {\n this.indices.clear();\n return;\n }\n const t0 = performance.now();\n const toLoad = enabled.filter((n) => !this.indices.has(n));\n const toRemove = [...this.indices.keys()].filter((n) => !enabled.includes(n));\n toRemove.forEach((n) => this.indices.delete(n));\n await Promise.all(toLoad.map(async (name) => {\n try {\n const resp = await fetch(`${window.api}/autocomplete/${name}`, { credentials: 'include' });\n if (!resp.ok) throw new Error(`${resp.status}`);\n const data = await resp.json();\n this.indices.set(name, new TagIndex(data));\n // Extract category colors from first loaded file\n if (data.categories) {\n Object.entries(data.categories).forEach(([id, cat]) => {\n const category: any = cat;\n if (category.color) this.categoryColors[id] = category.color;\n if (category.name) this.categoryNames[id] = category.name;\n });\n }\n const t1 = performance.now();\n log('autoComplete', { loaded: name, tags: data.tags?.length || 0, time: Math.round(t1 - t0) });\n timer(`autocompleteLoad:${name}`, t1 - t0);\n } catch (e) {\n log('autoComplete', { failed: name, error: e });\n }\n }));\n },\n\n searchAll(prefix, limit = 20) {\n if (this.indices.size === 0) return [];\n const all = [];\n this.indices.forEach((index) => {\n all.push(...index.search(prefix, limit));\n });\n // Deduplicate by name, keeping highest count\n const seen = new Map();\n all.forEach((tag) => {\n const existing = seen.get(tag.name);\n if (!existing || tag.count > existing.count) seen.set(tag.name, tag);\n });\n const results = [...seen.values()];\n results.sort((a, b) => b.count - a.count);\n return results.slice(0, limit);\n },\n};\n\n// -- Textarea integration --\n\n/**\n * Extract the current completion context at the cursor position.\n *\n * Returns { word, start, end, mode } where:\n * mode === 'tag': ordinary tag completion\n * mode === 'artist': leading `@` trigger; results filtered to artist category and inserted with `@` preserved\n * mode === 'lora': inside an unclosed ` 0) {\n const ch = value[wordStart - 1];\n if (ch === ',' || ch === '\\n') break;\n wordStart--;\n }\n // Skip leading whitespace between the separator and the typed word\n while (wordStart < selectionStart && value[wordStart] === ' ') wordStart++;\n const segment = value.slice(wordStart, selectionStart);\n // LoRA / extra-network trigger: unclosed `<` with `kind:` prefix\n const before = value.slice(0, selectionStart);\n const lastOpen = before.lastIndexOf('<');\n const lastClose = before.lastIndexOf('>');\n if (lastOpen > lastClose && lastOpen >= wordStart) {\n const inside = before.slice(lastOpen + 1); // e.g. \"lora:foo\", \"lora:\", \"lor\", or \"\"\n const colon = inside.indexOf(':');\n if (colon < 0) {\n // Bare `<` (or `` kind we ship,\n // so browse-all-loras; whatever the user typed gets overwritten on accept.\n return { word: '', start: lastOpen, end: selectionStart, mode: 'lora' };\n }\n if (inside.slice(0, colon).toLowerCase() === 'lora') {\n return { word: inside.slice(colon + 1), start: lastOpen, end: selectionStart, mode: 'lora' };\n }\n // Recognized colon but unknown kind, suppress completion.\n return null;\n }\n // Wildcard trigger: unclosed `__` that doesn't close within the current word\n if (segment.startsWith('__') && !segment.slice(2).includes('__')) {\n return { word: segment.slice(2), start: wordStart, end: selectionStart, mode: 'wildcard' };\n }\n // Artist trigger: leading `@` filters tag results to the artist category.\n if (segment.startsWith('@')) {\n return { word: segment.slice(1), start: wordStart, end: selectionStart, mode: 'artist' };\n }\n // Ordinary tag\n if (!segment) return null;\n return { word: segment, start: wordStart, end: selectionStart, mode: 'tag' };\n}\n\n// Booru schemas (danbooru/e621/sankaku) all assign category id 1 to artist tags.\nconst ARTIST_CATEGORY_ID = 1;\n\n/** Escape bare parens so tag names like `fate_(series)` aren't parsed as attention syntax. */\nfunction escapeParensForPrompt(name) {\n return name.replace(/([()])/g, '\\\\$1');\n}\n\n/**\n * Insert an extra-network reference at the current trigger position.\n * kind === 'lora': inserts `` over the range including the leading `<`\n * kind === 'wildcard': inserts `__name__` over the range including the leading `__`\n * Embeddings use insertTag directly so they go through comma-separator and paren-escape logic.\n */\nfunction insertExtraNetwork(textarea, item, kind) {\n const info = getCurrentWord(textarea);\n if (!info || info.mode !== kind) return;\n const { value } = textarea;\n const before = value.slice(0, info.start);\n const after = value.slice(info.end);\n let insertion;\n if (kind === 'lora') {\n insertion = ``;\n } else if (kind === 'wildcard') {\n insertion = `__${item.display ?? item.name}__`;\n } else {\n return;\n }\n textarea.value = before + insertion + after;\n const cursorPos = before.length + insertion.length;\n textarea.selectionStart = cursorPos;\n textarea.selectionEnd = cursorPos;\n if (typeof updateInput === 'function') updateInput(textarea);\n}\n\n/** Insert a tag at the current word position, replacing the typed prefix. */\nfunction insertTag(textarea, tagName, kind = 'tag') {\n const info = getCurrentWord(textarea);\n if (!info || (info.mode !== 'tag' && info.mode !== 'artist')) return;\n const { value } = textarea;\n const before = value.slice(0, info.start);\n const after = value.slice(info.end);\n // Build insertion: tag + separator. Parens in tag names are escaped so the prompt parser doesn't read them as attention syntax.\n const useComma = window.opts?.autocomplete_append_comma ?? true;\n const sep = useComma ? ',' : '';\n const needsSepBefore = before.length > 0 && before.trimEnd().length > 0 && !before.trimEnd().endsWith(',');\n const prefix = needsSepBefore ? `${sep} ` : '';\n let suffix = `${sep} `;\n if (after.length > 0 && after.trimStart().startsWith(',')) suffix = ' ';\n // Embedding names are file-system identifiers, so underscores must be preserved regardless of the user setting.\n // Tags and artists honor `autocomplete_keep_underscores`; default is to swap `_` for space.\n const keepUnderscores = window.opts?.autocomplete_keep_underscores ?? false;\n let body = tagName;\n if (kind !== 'embed' && !keepUnderscores) body = body.replace(/_/g, ' ');\n // Artist mode optionally keeps the `@` prefix (Anima syntax). The `@` is consumed for non-Anima models.\n if (info.mode === 'artist' && window.opts?.autocomplete_at_prefix_artist) body = `@${body}`;\n const insertion = `${prefix}${escapeParensForPrompt(body)}${suffix}`;\n textarea.value = before.trimEnd() + (before.trimEnd().length > 0 ? ' ' : '') + insertion + after.trimStart();\n // Position cursor after the inserted tag + separator\n const cursorPos = before.trimEnd().length + (before.trimEnd().length > 0 ? 1 : 0) + insertion.length;\n textarea.selectionStart = cursorPos;\n textarea.selectionEnd = cursorPos;\n // Sync with Gradio\n if (typeof updateInput === 'function') updateInput(textarea);\n}\n\n// -- Dropdown --\n\nconst dropdown = {\n el: null,\n listEl: null,\n selectedIndex: -1,\n results: [],\n textarea: null,\n query: '',\n visible: false,\n resizeObserver: null as ResizeObserver | null,\n\n init() {\n this.el = document.createElement('div');\n this.el.className = 'autocompleteResults';\n this.el.style.display = 'none';\n this.listEl = document.createElement('ul');\n this.listEl.className = 'autocompleteResultsList';\n this.el.appendChild(this.listEl);\n document.body.appendChild(this.el);\n this.el.addEventListener('mousedown', (e) => e.preventDefault()); // prevent blur on click\n this.el.addEventListener('click', (e) => {\n const li = e.target.closest('li');\n if (!li) return;\n const idx = [...this.listEl.children].indexOf(li);\n if (idx >= 0 && idx < this.results.length) {\n this.selectedIndex = idx;\n this.accept();\n }\n });\n this.resizeObserver = new ResizeObserver(() => {\n if (this.visible) this.position();\n });\n },\n\n show(results, textarea, query) {\n if (results.length === 0) { this.hide(); return; }\n // Switching textareas: clear prior state so a stale render can't leak across.\n if (this.textarea && this.textarea !== textarea) this.hide();\n if (this.textarea !== textarea) this.resizeObserver?.observe(textarea);\n this.results = results;\n this.textarea = textarea;\n this.query = query || '';\n this.selectedIndex = -1;\n this.render();\n this.position();\n this.el.style.display = '';\n this.visible = true;\n },\n\n hide() {\n if (this.textarea) this.resizeObserver?.unobserve(this.textarea);\n this.textarea = null;\n this.el.style.display = 'none';\n this.visible = false;\n this.results = [];\n this.selectedIndex = -1;\n },\n\n render() {\n const keepUnderscores = window.opts?.autocomplete_keep_underscores ?? false;\n const queryNorm = this.query.toLowerCase().replace(/ /g, '_');\n this.listEl.replaceChildren();\n this.results.forEach((tag, i) => {\n const li = document.createElement('li');\n if (i === this.selectedIndex) li.classList.add('selected');\n const dot = document.createElement('span');\n dot.className = 'autocomplete-category';\n const kind = tag.kind || 'tag';\n const kindStyle = KIND_GLYPHS[kind] || KIND_GLYPHS.tag;\n dot.style.color = kindStyle.color || engine.categoryColors[tag.category] || '#888';\n dot.textContent = kindStyle.glyph;\n dot.title = kind === 'tag' ? (engine.categoryNames[tag.category] || '') : kind;\n const name = document.createElement('span');\n name.className = 'autocomplete-tag';\n // Embeddings are file-name identifiers, so they always render as-is to match how they get inserted.\n const swapForKind = kind !== 'embed';\n const tagText = (swapForKind && !keepUnderscores) ? tag.display.replace(/_/g, ' ') : tag.display;\n const canonicalMatch = tag.name.indexOf(queryNorm);\n if (canonicalMatch >= 0 && queryNorm.length > 0) {\n const mark = document.createElement('mark');\n mark.textContent = tagText.slice(canonicalMatch, canonicalMatch + queryNorm.length);\n name.append(\n document.createTextNode(tagText.slice(0, canonicalMatch)),\n mark,\n document.createTextNode(tagText.slice(canonicalMatch + queryNorm.length)),\n );\n } else {\n name.textContent = tagText;\n }\n // Alias/translation-matched rows append \" (foreign)\" with the query fragment highlighted.\n let annotationTerm = null;\n if (tag.matchedVia === 'alias') annotationTerm = tag.matchedAlias;\n else if (tag.matchedVia === 'translation') annotationTerm = tag.matchedTerm;\n if (annotationTerm) {\n const annotationDisplay = (swapForKind && !keepUnderscores) ? annotationTerm.replace(/_/g, ' ') : annotationTerm;\n const annotationLower = annotationTerm.toLowerCase();\n const annotationMatch = annotationLower.indexOf(queryNorm);\n const prefix = tag.matchedVia === 'translation' ? ' \\u{1F310} ' : ' (';\n const suffix = tag.matchedVia === 'translation' ? '' : ')';\n name.appendChild(document.createTextNode(prefix));\n if (annotationMatch >= 0 && queryNorm.length > 0) {\n const mark = document.createElement('mark');\n mark.textContent = annotationDisplay.slice(annotationMatch, annotationMatch + queryNorm.length);\n name.append(\n document.createTextNode(annotationDisplay.slice(0, annotationMatch)),\n mark,\n document.createTextNode(annotationDisplay.slice(annotationMatch + queryNorm.length)),\n );\n } else {\n name.appendChild(document.createTextNode(annotationDisplay));\n }\n if (suffix) name.appendChild(document.createTextNode(suffix));\n }\n const count = document.createElement('span');\n count.className = 'autocomplete-count';\n count.textContent = tag.count > 0 ? formatCount(tag.count) : '';\n li.append(dot, name, count);\n li.addEventListener('mouseenter', () => {\n this.selectedIndex = i;\n this.updateSelection();\n });\n this.listEl.appendChild(li);\n });\n },\n\n position() {\n if (!this.textarea) return;\n const rect = this.textarea.getBoundingClientRect();\n // Position near the caret line instead of the textarea bottom\n const cursorBottom = caretViewportY(this.textarea);\n const anchorY = Math.max(rect.top, Math.min(cursorBottom, rect.bottom));\n const spaceBelow = window.innerHeight - anchorY;\n const dropHeight = Math.min(this.el.scrollHeight, 300);\n if (spaceBelow >= dropHeight || spaceBelow >= anchorY - rect.top) {\n this.el.style.top = `${anchorY + 2}px`;\n } else {\n this.el.style.top = `${anchorY - dropHeight - 2}px`;\n }\n this.el.style.left = `${rect.left}px`;\n this.el.style.width = `${rect.width}px`;\n },\n\n updateSelection() {\n [...this.listEl.children].forEach((li, i) => {\n li.classList.toggle('selected', i === this.selectedIndex);\n });\n const selected = this.listEl.children[this.selectedIndex];\n if (selected) selected.scrollIntoView({ block: 'nearest' });\n },\n\n navigate(dir) {\n if (this.results.length === 0) return;\n if (this.selectedIndex === -1) {\n this.selectedIndex = dir > 0 ? 0 : this.results.length - 1;\n } else {\n this.selectedIndex = (this.selectedIndex + dir + this.results.length) % this.results.length;\n }\n this.updateSelection();\n },\n\n accept() {\n if (this.selectedIndex < 0 || this.selectedIndex >= this.results.length) {\n // Tab with no selection: select first\n if (this.results.length > 0) {\n this.selectedIndex = 0;\n this.updateSelection();\n }\n return;\n }\n const result = this.results[this.selectedIndex];\n if (this.textarea) {\n if (result.kind === 'lora' || result.kind === 'wildcard') {\n insertExtraNetwork(this.textarea, result, result.kind);\n } else {\n // 'embed' kind and untagged tag results both go through insertTag (comma-aware, paren-escaped).\n insertTag(this.textarea, result.display ?? result.name, result.kind);\n }\n }\n this.hide();\n },\n};\n\n// -- Event handlers --\n\nlet debounceInput: ReturnType | undefined;\nlet debounceFocus: ReturnType | undefined;\n\nfunction onInput(textarea) {\n if (!active) return;\n // IME candidate window open: value isn't committed, and Enter would race with tag accept.\n if (textarea.dataset.imeActive === '1') return;\n const minChars = window.opts?.autocomplete_min_chars ?? 3;\n const info = getCurrentWord(textarea);\n if (!info) {\n dropdown.hide();\n return;\n }\n // Threshold by mode. Trigger characters carry their own signal so we can lower (or zero) the bar.\n let threshold = minChars;\n if (info.mode === 'lora' || info.mode === 'wildcard') threshold = 0;\n else if (info.mode === 'artist') threshold = 1;\n if (info.word.length < threshold) {\n dropdown.hide();\n return;\n }\n clearTimeout(debounceInput);\n debounceInput = setTimeout(() => {\n let results;\n if (info.mode === 'lora') {\n results = xnEngine.searchLoras(info.word);\n } else if (info.mode === 'wildcard') {\n results = xnEngine.searchWildcards(info.word);\n } else if (info.mode === 'artist') {\n // `@` trigger: tag-search filtered to the artist category. The category-1 color carries the visual cue.\n results = engine.searchAll(info.word).filter((t) => t.category === ARTIST_CATEGORY_ID);\n } else {\n const tagResults = engine.searchAll(info.word);\n const embedResults = xnEngine.searchEmbeddings(info.word);\n // Embeddings fold into tag-mode results (a1111 tagcomplete parity).\n results = [...embedResults, ...tagResults];\n }\n dropdown.show(results, textarea, info.word);\n }, 150);\n}\n\nfunction onKeyDown(e) {\n if (!dropdown.visible) return;\n if (e.isComposing) return; // IME candidate selection, let the browser commit the candidate\n // Modifier + nav/accept keys belong to other handlers (editAttention.js on Ctrl+Arrow,\n // generate hotkey on Ctrl+Enter). Let them through even with the dropdown open.\n const hasModifier = e.ctrlKey || e.metaKey || e.altKey;\n switch (e.key) {\n case 'ArrowDown':\n if (hasModifier) return;\n e.preventDefault();\n e.stopPropagation();\n dropdown.navigate(1);\n break;\n case 'ArrowUp':\n if (hasModifier) return;\n e.preventDefault();\n e.stopPropagation();\n dropdown.navigate(-1);\n break;\n case 'Enter':\n if (hasModifier) return;\n if (dropdown.selectedIndex >= 0) {\n e.preventDefault();\n e.stopPropagation();\n dropdown.accept();\n }\n break;\n case 'Tab':\n if (hasModifier) return;\n e.preventDefault();\n e.stopPropagation();\n dropdown.accept();\n break;\n case 'Escape':\n e.preventDefault();\n e.stopPropagation();\n dropdown.hide();\n break;\n default:\n break;\n }\n}\n\n/** Attach autocomplete to a single textarea. */\nfunction attachAutocomplete(textarea) {\n textarea.addEventListener('input', () => onInput(textarea));\n textarea.addEventListener('keydown', onKeyDown);\n textarea.addEventListener('compositionstart', () => { textarea.dataset.imeActive = '1'; });\n textarea.addEventListener('compositionend', () => { delete textarea.dataset.imeActive; });\n textarea.addEventListener('focusin', () => {\n if (dropdown.visible && dropdown.textarea && dropdown.textarea !== textarea) dropdown.hide();\n // Cancel any pending hide from a recent blur so refocusing within 200ms doesn't close the dropdown.\n clearTimeout(debounceFocus);\n debounceFocus = undefined;\n // Re-fire input handling so a partial tag at the cursor reopens the dropdown.\n onInput(textarea);\n });\n textarea.addEventListener('focusout', () => {\n // Cancel any in-flight debounced dropdown.show; otherwise it fires against a stale textarea.\n clearTimeout(debounceInput);\n debounceFocus = setTimeout(() => dropdown.hide(), 200);\n });\n}\n\n// -- Prompt textarea IDs --\n\nconst PROMPT_IDS = [\n 'txt2img_prompt', 'txt2img_neg_prompt',\n 'img2img_prompt', 'img2img_neg_prompt',\n 'control_prompt', 'control_neg_prompt',\n 'video_prompt', 'video_neg_prompt',\n];\n\n// -- Active button --\n\nfunction patchActiveButton() {\n const buttons = [...gradioApp().querySelectorAll('.autocomplete-active')];\n active = window.opts?.autocomplete_active || false;\n buttons.forEach((btn) => {\n btn.classList.toggle('autocomplete-active', active);\n btn.classList.toggle('autocomplete-inactive', !active);\n btn.parentElement.onclick = () => {\n active = !active;\n window.opts.autocomplete_active = !active;\n btn.classList.toggle('autocomplete-active', active);\n btn.classList.toggle('autocomplete-inactive', !active);\n };\n });\n}\n\n// -- Config bridge --\n\n/** Monkey-patch script config bridge textboxes to push autocomplete config changes to window.opts immediately. */\nlet bridgeWarnedMissingDescriptor = false;\nfunction patchConfigBridge() {\n const proto = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value');\n if (!proto?.get || !proto?.set) {\n if (!bridgeWarnedMissingDescriptor) {\n log('autoComplete', { bridge: 'skipped', reason: 'HTMLTextAreaElement.prototype.value descriptor missing' });\n bridgeWarnedMissingDescriptor = true;\n }\n return;\n }\n const elements = gradioApp().querySelectorAll('[id$=\"_tag_autocomplete_config_json\"]');\n for (const el of elements) {\n const textarea = el.querySelector('textarea');\n if (!textarea || textarea.acBridgePatched) continue;\n textarea.acBridgePatched = true;\n Object.defineProperty(textarea, 'value', {\n set(newValue) {\n const oldValue = proto.get.call(textarea);\n proto.set.call(textarea, newValue);\n if (oldValue !== newValue && newValue) {\n try {\n const cfg = JSON.parse(newValue);\n for (const [key, val] of Object.entries(cfg)) window.opts[key] = val;\n executeCallbacks(optionsChangedCallbacks);\n } catch { /* ignore parse errors; the bridge is best-effort */ }\n }\n },\n get() { return proto.get.call(textarea); },\n });\n }\n}\n\n// -- Initialization --\n\nexport async function initAutocomplete() {\n const t0 = performance.now();\n const enabled = window.opts?.autocomplete_enabled || [];\n active = window.opts?.autocomplete_active || false;\n log('autoComplete', { active, enabled });\n // Inject styles (CSS files in javascript/ are not auto-loaded)\n const style = document.createElement('style');\n style.textContent = `\n .autocompleteResults { position: fixed; z-index: 9999; max-height: 300px; overflow-y: auto;\n background: var(--sd-main-background-color, var(--background-fill-primary, #1f2937));\n border: 1px solid var(--sd-input-border-color, var(--border-color-primary, #374151));\n border-radius: var(--sd-border-radius, 6px); box-shadow: 0 4px 16px rgba(0,0,0,0.4);\n font-size: 13px; scrollbar-width: thin; color: var(--body-text-color-subdued); }\n .autocompleteResultsList { list-style: none; margin: 0; padding: 4px 0; }\n .autocompleteResultsList > li { display: flex; align-items: center; padding: 6px 12px; cursor: pointer;\n gap: 8px; line-height: 1.4; transition: background 0.1s ease; border-bottom: 1px solid rgba(255,255,255,0.03); }\n .autocompleteResultsList > li:last-child { border-bottom: none; }\n .autocompleteResultsList > li:hover { background: var(--sd-panel-background-color, var(--input-background-fill-focus, #374151)); }\n .autocompleteResultsList > li.selected { background: var(--sd-main-accent-color, var(--button-primary-background-fill, #4b5563)); }\n .autocomplete-category { font-size: 10px; flex-shrink: 0; width: 10px; text-align: center; cursor: help; }\n .autocomplete-tag { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }\n .autocomplete-tag mark { background: transparent; color: inherit; font-weight: 700; }\n .autocomplete-count { font-size: 0.75em; opacity: 0.45; flex-shrink: 0; font-variant-numeric: tabular-nums;\n background: rgba(255,255,255,0.06); padding: 1px 6px; border-radius: 8px; min-width: 28px; text-align: right; }\n `;\n document.head.appendChild(style);\n dropdown.init();\n await engine.loadEnabled();\n xnEngine.loadAll();\n // Attach to all prompt textareas; even if no dictionaries loaded yet, they may be enabled later via script UI\n let attached = 0;\n PROMPT_IDS.forEach((id) => {\n const textarea = gradioApp().querySelector(`#${id} > label > textarea`);\n if (textarea) {\n attachAutocomplete(textarea);\n attached++;\n }\n });\n // Reload when settings change\n\n async function optionsChangedCallback() {\n const newActive = window.opts?.autocomplete_active || false;\n const newEnabled = window.opts?.autocomplete_enabled || [];\n const currentKeys = [...engine.indices.keys()].sort().join(',');\n const newKeys = [...newEnabled].sort().join(',');\n if ((currentKeys !== newKeys) || (active !== newActive)) {\n log('autoComplete', { reload: newEnabled });\n await engine.loadEnabled();\n active = newActive;\n patchActiveButton();\n }\n xnEngine.loadAll();\n }\n onOptionsChanged(optionsChangedCallback);\n // Watch for config updates from the script UI bridge\n patchConfigBridge();\n patchActiveButton();\n onAfterUiUpdate(patchConfigBridge);\n const t1 = performance.now();\n log('autoComplete', { attached, dicts: engine.indices.size, time: Math.round(t1 - t0) });\n timer('autocompleteInit', t1 - t0);\n}\n", "/* eslint-disable @typescript-eslint/no-use-before-define */\nimport { log } from './logger';\nimport { gradioApp } from './script';\nimport { timer } from './timers';\n\nlet hintsObserver: MutationObserver | null = null;\nconst allLocales = ['en', 'tb', 'nb', 'hr', 'es', 'it', 'fr', 'de', 'pt', 'ru', 'zh', 'ja', 'ko', 'hi', 'ar', 'bn', 'ur', 'id', 'vi', 'tr', 'sr', 'po', 'he', 'xx', 'qq', 'tlh'];\nconst localeData = {\n prev: null,\n locale: null,\n data: [],\n timeout: null,\n finished: false,\n initial: true,\n type: 2,\n hint: null,\n btn: null,\n expandTimeout: undefined, // Property for expansion timeout\n currentElement: null, // Track current element for expansion\n};\nlet localeTimeout: ReturnType | undefined;\nconst isTouchDevice = 'ontouchstart' in window;\n\nasync function cycleLocale() {\n clearTimeout(localeTimeout);\n localeTimeout = setTimeout(() => {\n log('cycleLocale', localeData.prev, localeData.locale);\n const index = allLocales.indexOf(localeData.prev);\n localeData.locale = allLocales[(index + 1) % allLocales.length];\n localeData.btn.innerText = localeData.locale;\n // localeData.btn.style.backgroundColor = localeData.locale !== 'en' ? 'var(--primary-500)' : '';\n localeData.finished = false;\n localeData.data = [];\n localeData.prev = localeData.locale;\n window.opts.ui_locale = localeData.locale;\n setHints();\n }, 250);\n}\n\nasync function resetLocale() {\n clearTimeout(localeTimeout); // Prevent the single click logic\n localeData.locale = 'en';\n log('resetLocale', localeData.locale);\n const index = allLocales.indexOf(localeData.locale);\n localeData.locale = allLocales[(index) % allLocales.length];\n localeData.btn.innerText = localeData.locale;\n localeData.finished = false;\n localeData.data = [];\n window.opts.ui_locale = localeData.locale;\n setHints();\n}\n\nasync function tooltipCreate() {\n localeData.hint = document.createElement('div');\n localeData.hint.className = 'tooltip';\n localeData.hint.id = 'tooltip-container';\n localeData.hint.innerText = 'this is a hint';\n gradioApp().appendChild(localeData.hint);\n localeData.btn = gradioApp().getElementById('locale-container');\n if (!localeData.btn) {\n localeData.btn = document.createElement('div');\n localeData.btn.className = 'locale';\n localeData.btn.id = 'locale-container';\n gradioApp().appendChild(localeData.btn);\n }\n localeData.btn.innerText = localeData.locale;\n localeData.btn.ondblclick = resetLocale;\n localeData.btn.onclick = cycleLocale;\n if (window.opts.tooltips === 'None') localeData.type = 0;\n if (window.opts.tooltips === 'Browser default') localeData.type = 1;\n if (window.opts.tooltips === 'UI tooltips') localeData.type = 2;\n\n if (localeData.type === 2) { // setup event delegation for tooltips instead of individual listeners\n if (isTouchDevice) {\n gradioApp().addEventListener('touchstart', tooltipShowDelegated);\n gradioApp().addEventListener('touchend', tooltipHideDelegated);\n }\n gradioApp().addEventListener('pointerover', tooltipShowDelegated);\n gradioApp().addEventListener('pointerout', tooltipHideDelegated);\n }\n if (!hintsObserver) initializeDOMObserver();\n}\n\nasync function expandTooltip(element, longHint) {\n if (localeData.currentElement === element && localeData.hint.classList.contains('tooltip-show')) {\n const ring = localeData.hint.querySelector('.tooltip-progress-ring');\n if (ring) ring.style.opacity = '0';\n localeData.hint.classList.add('tooltip-expanded');\n setTimeout(() => {\n const longContent = localeData.hint.querySelector('.long-content');\n if (longContent) longContent.classList.add('show');\n }, 100);\n }\n}\n\nasync function tooltipShowDelegated(e) { // use event delegation to handle dynamically created elements\n if (e.target.dataset && e.target.dataset.hint) tooltipShow(e);\n}\n\nasync function tooltipHideDelegated(e) {\n if (e.target.dataset && e.target.dataset.hint) tooltipHide(e);\n}\n\nasync function tooltipShow(e) {\n if (localeData.expandTimeout) { // clear any existing expansion timeout\n clearTimeout(localeData.expandTimeout);\n localeData.expandTimeout = undefined;\n }\n\n localeData.hint.classList.remove('tooltip-expanded'); // remove expanded class and reset current element\n localeData.currentElement = e.target;\n\n if (e.target.dataset.hint) {\n const progressRing = ` // create progress ring SVG\n
    \n \n \n \n \n
    \n `;\n // set up the complete content structure from the start\n let content = `\n
    \n ${e.target.textContent}\n ${e.target.dataset.longHint ? progressRing : ''}\n
    \n
    \n ${e.target.dataset.hint}\n `;\n if (e.target.dataset.longHint) content += `
    ${e.target.dataset.longHint}
    `; // add long content if available, but keep it hidden\n if (e.target.dataset.reload) { // add reload notice if needed\n const reloadType = e.target.dataset.reload;\n let reloadText = '';\n if (reloadType === 'model') reloadText = 'Requires model reload';\n else if (reloadType === 'server') reloadText = 'Requires server restart';\n if (reloadText) {\n content += `\n
    \n
    \n ${reloadText}\n
    \n `;\n }\n }\n\n localeData.hint.innerHTML = content;\n localeData.hint.classList.add('tooltip-show');\n\n if (e.clientX > window.innerWidth / 2) localeData.hint.classList.add('tooltip-left');\n else localeData.hint.classList.remove('tooltip-left');\n\n if (e.target.dataset.longHint) { // set up expansion timer if long hint is available\n const ring = localeData.hint.querySelector('.tooltip-progress-ring'); // start progress ring animation\n const ringProgress = localeData.hint.querySelector('.ring-progress');\n if (ring && ringProgress) {\n setTimeout(() => {\n ring.classList.add('active');\n ringProgress.classList.add('animate');\n }, 100);\n }\n localeData.expandTimeout = setTimeout(() => expandTooltip(e.target, e.target.dataset.longHint), 3000);\n }\n }\n}\n\nasync function tooltipHide(e) {\n if (localeData.expandTimeout) {\n clearTimeout(localeData.expandTimeout);\n localeData.expandTimeout = undefined;\n }\n localeData.hint.classList.remove('tooltip-show', 'tooltip-expanded');\n localeData.currentElement = null;\n}\n\nasync function replaceButtonText(el) {\n // https://www.nerdfonts.com/cheat-sheet\n // use unicode of icon with format nf-md-_circle\n const textIcons = {\n Generate: '\\uf144',\n Enqueue: '\\udb81\\udc17',\n Stop: '\\udb81\\ude66',\n Skip: '\\udb81\\ude61',\n Pause: '\\udb80\\udfe5',\n Restore: '\\udb82\\udd9b',\n Clear: '\\udb80\\udd59',\n Networks: '\\uf261',\n };\n if (textIcons[el.innerText]) {\n el.classList.add('button-icon');\n el.innerText = textIcons[el.innerText];\n }\n}\n\nasync function getLocaleData(desiredLocale = null) {\n if (desiredLocale) desiredLocale = desiredLocale.split(':')[0];\n if (desiredLocale === 'Auto') {\n try {\n localeData.locale = navigator.languages && navigator.languages.length ? navigator.languages[0] : navigator.language;\n localeData.locale = localeData.locale.split('-')[0];\n localeData.prev = localeData.locale;\n } catch (e) {\n localeData.locale = 'en';\n log('getLocale', e);\n }\n } else {\n localeData.locale = desiredLocale || 'en';\n localeData.prev = localeData.locale;\n }\n log('getLocale', { lang: desiredLocale, locale: localeData.locale });\n // primary\n let json: any = {};\n try {\n let res = await fetch(`${window.subpath}/file=ui/locale/locale_${localeData.locale}.json`);\n if (!res || !res.ok) {\n localeData.locale = 'en';\n res = await fetch(`${window.subpath}/file=ui/locale/locale_${localeData.locale}.json`);\n }\n json = await res.json();\n } catch { /**/ }\n\n try {\n const res = await fetch(`${window.subpath}/file=ui/locale/override_${localeData.locale}.json`);\n if (res && res.ok) json.override = await res.json();\n } catch { /**/ }\n\n return json;\n}\n\nasync function replaceTextContent(el, text) {\n if (el.children.length === 1 && el.firstElementChild.classList.contains('mask-icon')) return;\n if (el.querySelector('span')) el = el.querySelector('span');\n if (el.querySelector('div')) el = el.querySelector('div');\n if (el.classList.contains('mask-icon')) return; // skip icon buttons\n if (el.dataset.selector) { // replace on rehosted child if exists\n el = el.firstElementChild || el.querySelector(el.dataset.selector);\n replaceTextContent(el, text);\n return;\n }\n el.textContent = text;\n}\n\nasync function setHint(el, entry) {\n if (localeData.type === 1) {\n el.title = entry.hint;\n } else if (localeData.type === 2) {\n el.dataset.hint = entry.hint;\n if (entry.longHint && entry.longHint.length > 0) el.dataset.longHint = entry.longHint;\n if (entry.reload && entry.reload.length > 0) el.dataset.reload = entry.reload;\n } else {\n // tooltips disabled\n }\n}\n\nfunction createLocaleJSON() {\n const excludeText = ['\u25BC']; // add any common non-label elements to exclude\n const ecxcludeIds = ['logo_nav']; // add any specific element IDs to exclude\n const elements = [...new Set([\n ...Array.from(gradioApp().querySelectorAll('button')),\n ...Array.from(gradioApp().querySelectorAll('h1')),\n ...Array.from(gradioApp().querySelectorAll('h2')),\n ...Array.from(gradioApp().querySelectorAll('h3')),\n ...Array.from(gradioApp().querySelectorAll('.hint')),\n ...Array.from(gradioApp().querySelectorAll('label > span')),\n ...Array.from(gradioApp().querySelectorAll('.label-wrap > span')),\n ...Array.from(gradioApp().querySelectorAll('span[data-testid=\"block-info\"]')),\n ])];\n const json = {};\n const allSeen = {};\n for (const el of elements) {\n const label = el.textContent.trim();\n if (!label || label.length < 1 || label.length > 1024) continue; // likely not UI element\n if (excludeText.includes(label)) continue; // skip common non-label elements\n if (ecxcludeIds.includes(el.id)) continue; // skip specific element IDs\n\n let hint = el.dataset.hint || '';\n if (hint.toLowerCase() === label.toLowerCase()) hint = ''; // skip if hint is same as label\n if (Object.keys(allSeen).includes(label.toLowerCase())) {\n if (hint.length === 0 || allSeen[label.toLowerCase()] === hint) continue; // seen this label and hint is empty or same as before\n hint = allSeen[label.toLowerCase()]; // use existing hint for this label\n }\n allSeen[label.toLowerCase()] = hint; // track seen labels\n\n let section = label[0].toLowerCase();\n if (section >= '0' && section <= '9') section = '0';\n if ((section < 'a' || section > 'z') && section !== '0') section = '_';\n\n let ui = el.closest('.group-extension')\n || el.closest('.group-scripts')\n || el.closest('.main-tab')\n || el.closest('.settings_section')\n || el.closest('.tabitem')\n || 'other';\n ui = ui?.id?.replace('_tabitem_parent', '').replace('_section_row', '');\n if (ui?.includes('_script')) ui = ui?.split('_').slice(1).join('_').split(':')[0];\n\n if (!json[section]) json[section] = [];\n const entry = { id: el.id || '', label, localized: '', hint, ui };\n json[section].push(entry); // add new entry\n }\n const sorted = Object.keys(json).sort().reduce((obj, key) => {\n obj[key] = json[key];\n return obj;\n }, {});\n console.log('localeJSON', sorted);\n}\n\nexport async function setHints() {\n let json: any;\n let overrideData: any[] = [];\n if (localeData.finished) return;\n if (Object.keys(opts).length === 0) return;\n const elements = [...new Set([\n ...Array.from(gradioApp().querySelectorAll('button')),\n ...Array.from(gradioApp().querySelectorAll('h2')),\n ...Array.from(gradioApp().querySelectorAll('label > span')),\n ...Array.from(gradioApp().querySelectorAll('.label-wrap > span')),\n ...Array.from(gradioApp().querySelectorAll('span[data-testid=\"block-info\"]')), // radio/checkboxgroup titles render as a bare block-info span, not under a label\n ])];\n if (elements.length === 0) return;\n if (localeData.data.length === 0) {\n json = await getLocaleData(window.opts.ui_locale);\n overrideData = Object.values(json.override || {}).flat().filter((e: any) => e.hint.length > 0);\n const jsonData = Object.values(json).flat().filter((e: any) => e.hint.length > 0);\n localeData.data = [...overrideData, ...jsonData];\n }\n if (!localeData.hint) tooltipCreate();\n let localized = 0;\n let hints = 0;\n const t0 = performance.now();\n\n for (const el of elements) {\n // localize elements text\n let found;\n if (el.id) found = localeData.data.find((l) => l.id && (l.id === el.id || el.id.endsWith(l.id))); // prefer id match for disambiguation\n if (!found) {\n if (el.dataset.original) found = localeData.data.find((l) => l.label.toLowerCase().trim() === el.dataset.original.toLowerCase().trim());\n else found = localeData.data.find((l) => l.label.toLowerCase().trim() === el.textContent.toLowerCase().trim());\n }\n if (found?.localized?.length > 0) {\n if (!el.dataset.original) el.dataset.original = el.textContent;\n replaceTextContent(el, found.localized);\n localized++;\n } else if (found?.label && !localeData.initial && (localeData.locale === 'en')) { // reset to english\n replaceTextContent(el, found.label);\n }\n // set hints\n if (found?.hint?.length > 0) {\n hints++;\n setHint(el, found);\n }\n }\n localeData.finished = true;\n localeData.initial = false;\n const t1 = performance.now();\n timer('setHints', t1 - t0);\n // localeData.btn.style.backgroundColor = localeData.locale !== 'en' ? 'var(--primary-500)' : '';\n log('touchDevice', isTouchDevice);\n log('setHints', { type: localeData.type, locale: localeData.locale, elements: elements.length, localized, hints, data: localeData.data.length, override: overrideData.length, time: Math.round(t1 - t0) });\n // sortUIElements();\n}\n\n// Apply hints to a single element immediately\nasync function applyHintToElement(el) {\n if (!localeData.data || localeData.data.length === 0) return;\n // if (!el.textContent) return;\n\n // check if element matches our selector criteria\n const isValidElement = el.tagName === 'BUTTON'\n || el.tagName === 'H2'\n || el.classList.contains('hint')\n || (el.tagName === 'SPAN' && (el.parentElement?.tagName === 'LABEL' || el.parentElement?.classList.contains('label-wrap') || el.dataset.testid === 'block-info'));\n if (!isValidElement) return;\n\n let found; // find matching hint data - prefer id match for disambiguation\n if (el.id) found = localeData.data.find((l) => l.id && (l.id === el.id || el.id.endsWith(l.id)));\n if (!found) {\n if (el.dataset.original) found = localeData.data.find((l) => l.label.toLowerCase().trim() === el.dataset.original.toLowerCase().trim());\n else found = localeData.data.find((l) => l.label.toLowerCase().trim() === el.textContent.toLowerCase().trim());\n }\n\n if (el.textContent && el.textContent.length > 0 && found?.localized?.length > 0) { // apply localization if found\n if (!el.dataset.original) el.dataset.original = el.textContent;\n replaceTextContent(el, found.localized);\n }\n\n if (found?.hint?.length > 0) setHint(el, found); // apply hint if found\n}\n\n// Initialize MutationObserver for immediate hint application\nfunction initializeDOMObserver() {\n if (hintsObserver) hintsObserver.disconnect();\n\n hintsObserver = new MutationObserver((mutations) => {\n // Process added nodes immediately\n for (const mutation of mutations) {\n if (mutation.type === 'childList') {\n for (const node of mutation.addedNodes) {\n if (node.nodeType === Node.ELEMENT_NODE) {\n // Apply hints to the node itself\n applyHintToElement(node);\n\n // Apply hints to all relevant children\n const elements = [\n ...Array.from(node.querySelectorAll('button')),\n ...Array.from(gradioApp().querySelectorAll('h1')),\n ...Array.from(gradioApp().querySelectorAll('h2')),\n ...Array.from(gradioApp().querySelectorAll('h3')),\n ...Array.from(gradioApp().querySelectorAll('.hint')),\n ...Array.from(node.querySelectorAll('label > span')),\n ...Array.from(node.querySelectorAll('.label-wrap > span')),\n ...Array.from(node.querySelectorAll('span[data-testid=\"block-info\"]')),\n ];\n\n // Include the node itself if it matches\n if (node.matches && (\n node.matches('button')\n || node.matches('h1')\n || node.matches('h2')\n || node.matches('h3')\n || node.matches('label > span')\n || node.matches('.hint')\n || node.matches('.label-wrap > span')\n || node.matches('span[data-testid=\"block-info\"]')\n )) {\n elements.push(node);\n }\n\n // Apply hints immediately to all found elements\n elements.forEach((el) => applyHintToElement(el));\n }\n }\n }\n }\n });\n\n // Start observing the entire gradio app for changes\n const targetNode = gradioApp();\n if (targetNode) {\n hintsObserver.observe(targetNode, {\n childList: true,\n subtree: true,\n });\n }\n}\n\nexport function disconnectHintsObserver() {\n if (hintsObserver) {\n hintsObserver.disconnect();\n hintsObserver = null;\n }\n}\n\n// Export for external use if needed\nconst forceReapplyHints = () => setHints();\n", "import { gradioApp, getUICurrentTabContent } from './script';\nimport { log } from './logger';\nimport { authFetch } from './authWrap';\nimport { quickApplyStyle, quickSaveStyle } from './extraNetworks';\n\ninterface ContextMenuItem {\n id: string;\n name: string;\n func: () => void;\n primary: boolean;\n}\n\nconst contextMenuInit = () => {\n let eventListenerApplied = false;\n const menuSpecs = new Map();\n\n const uid = () => Date.now().toString(36) + Math.random().toString(36).substring(2);\n\n function showContextMenu(event: MouseEvent, _element: Element, menuEntries: ContextMenuItem[]): void {\n const posx = event.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;\n const posy = event.clientY + document.body.scrollTop + document.documentElement.scrollTop;\n const oldMenu = gradioApp().querySelector('#context-menu');\n if (oldMenu) oldMenu.remove();\n const contextMenu = document.createElement('nav');\n contextMenu.id = 'context-menu';\n contextMenu.style.top = `${posy}px`;\n contextMenu.style.left = `${posx}px`;\n const contextMenuList = document.createElement('ul');\n contextMenuList.className = 'context-menu-items';\n contextMenu.append(contextMenuList);\n menuEntries.forEach((entry) => {\n const contextMenuEntry = document.createElement('a');\n contextMenuEntry.innerHTML = entry.name;\n contextMenuEntry.addEventListener('click', () => entry.func());\n contextMenuList.append(contextMenuEntry);\n });\n gradioApp().appendChild(contextMenu);\n const menuWidth = contextMenu.offsetWidth + 4;\n const menuHeight = contextMenu.offsetHeight + 4;\n const windowWidth = window.innerWidth;\n const windowHeight = window.innerHeight;\n if ((windowWidth - posx) < menuWidth) contextMenu.style.left = `${windowWidth - menuWidth}px`;\n if ((windowHeight - posy) < menuHeight) contextMenu.style.top = `${windowHeight - menuHeight}px`;\n }\n\n function appendContextMenuOption(targetElementSelector: string, entryName: string, entryFunction: () => void, primary = false): string {\n let currentItems = menuSpecs.get(targetElementSelector);\n if (!currentItems) {\n currentItems = [];\n menuSpecs.set(targetElementSelector, currentItems);\n }\n const newItem = {\n id: `${targetElementSelector}_${uid()}`,\n name: entryName,\n func: entryFunction,\n primary,\n // isNew: true,\n };\n currentItems.push(newItem);\n return newItem.id;\n }\n\n function removeContextMenuOption(id: string): void {\n menuSpecs.forEach((v, k) => {\n let index = -1;\n v.forEach((e, ei) => {\n if (e.id === id) { index = ei; }\n });\n if (index >= 0) v.splice(index, 1);\n });\n }\n\n window.appendContextMenuOption = appendContextMenuOption;\n window.removeContextMenuOption = removeContextMenuOption;\n\n async function addContextMenuEventListener(): Promise {\n if (eventListenerApplied) return;\n log('initContextMenu');\n gradioApp().addEventListener('click', (e: Event) => {\n const mouseEvent = e as MouseEvent;\n if (!mouseEvent.isTrusted) return;\n const oldMenu = gradioApp().querySelector('#context-menu');\n if (oldMenu) oldMenu.remove();\n menuSpecs.forEach((v, k) => {\n const items = v.filter((item) => item.primary);\n const target = mouseEvent.target as Element | null;\n if (!target) return;\n const matched = target.closest(k);\n if (items.length > 0 && matched) {\n showContextMenu(mouseEvent, matched, items);\n mouseEvent.preventDefault();\n }\n });\n });\n gradioApp().addEventListener('contextmenu', (e: Event) => {\n const mouseEvent = e as MouseEvent;\n const oldMenu = gradioApp().querySelector('#context-menu');\n if (oldMenu) oldMenu.remove();\n menuSpecs.forEach((v, k) => {\n const items = v.filter((item) => !item.primary);\n const target = mouseEvent.target as Element | null;\n if (!target) return;\n const matched = target.closest(k);\n if (items.length > 0 && matched) {\n showContextMenu(mouseEvent, matched, items);\n mouseEvent.preventDefault();\n }\n });\n });\n eventListenerApplied = true;\n }\n return [appendContextMenuOption, removeContextMenuOption, addContextMenuEventListener];\n};\n\nconst initContextResponse = contextMenuInit();\nconst appendContextMenuOption = initContextResponse[0];\nconst removeContextMenuOption = initContextResponse[1];\nconst addContextMenuEventListener = initContextResponse[2] as () => void;\n\nlet generateOnRepeatInterval: ReturnType | null = null;\n\nexport const generateForever = (genbuttonid: string): void => {\n if (generateOnRepeatInterval) {\n log('generateForever: cancel');\n clearInterval(generateOnRepeatInterval);\n generateOnRepeatInterval = null;\n } else {\n const genbutton = gradioApp().querySelector(genbuttonid);\n if (!(genbutton instanceof HTMLElement)) return;\n const isBusy = () => {\n let busy = document.getElementById('progressbar')?.style.display === 'block';\n if (!busy) {\n // Also check in Modern UI\n const outerButton = genbutton.parentElement.closest('button');\n busy = outerButton?.classList.contains('generate') && outerButton?.classList.contains('active');\n }\n return busy;\n };\n log('generateForever: start');\n if (!isBusy()) genbutton.click();\n generateOnRepeatInterval = setInterval(() => {\n if (!isBusy()) genbutton.click();\n }, 500);\n }\n};\nwindow.generateForever = generateForever;\n\nconst reprocessClick = (tabId: string, state: string): void => {\n const btn = document.getElementById(`${tabId}_${state}`);\n window.submit_state = state;\n if (btn) btn.click();\n};\n\nconst getStatus = async () => {\n const headers = new Headers();\n const body = JSON.stringify({ id_task: -1, id_live_preview: false });\n headers.set('Content-Type', 'application/json');\n const tab = getUICurrentTabContent()?.id.replace('tab_', '') || '';\n const el = gradioApp().querySelector(`#html_log_${tab} .performance p`);\n\n let res;\n let data;\n res = await fetch('./internal/progress', { method: 'POST', headers, body });\n if (res?.ok) {\n data = await res.json();\n log('progressInternal:', data);\n if (el) el.innerText += `\\nProgress internal:\\n${JSON.stringify(data, null, 2)}`;\n }\n res = await authFetch('./sdapi/v1/progress?skip_current_image=true', { method: 'GET', headers });\n if (res?.ok) {\n data = await res.json();\n log('progressAPI:', data);\n if (el) el.innerText += `\\nProgress API:\\n${JSON.stringify(data, null, 2)}`;\n }\n};\n\nexport async function initContextMenu() {\n for (const tab of ['txt2img', 'img2img', 'control', 'video']) {\n appendContextMenuOption(`#${tab}_generate`, 'Get server status', getStatus);\n appendContextMenuOption(`#${tab}_generate`, 'Copy prompt to clipboard', () => navigator.clipboard.writeText(document.querySelector(`#${tab}_prompt > label > textarea`).value));\n appendContextMenuOption(`#${tab}_generate`, 'Generate forever', () => generateForever(`#${tab}_generate`));\n appendContextMenuOption(`#${tab}_generate`, 'Apply selected style', quickApplyStyle);\n appendContextMenuOption(`#${tab}_generate`, 'Quick save style', quickSaveStyle);\n appendContextMenuOption(`#${tab}_reprocess`, 'Decode full quality', () => reprocessClick(tab, 'reprocess_decode'), true);\n appendContextMenuOption(`#${tab}_reprocess`, 'Refine & HiRes pass', () => reprocessClick(tab, 'reprocess_refine'), true);\n appendContextMenuOption(`#${tab}_reprocess`, 'Detailer pass', () => reprocessClick(tab, 'reprocess_detail'), true);\n }\n // Right-click send-to-control button for prompt/params-only transfer.\n for (const tab of ['gallery', 'txt2img', 'img2img', 'extras']) {\n appendContextMenuOption(`#${tab}_tabitem #control_tab`, 'Transfer only prompt to Images tab', () => {\n document.querySelector(`#image_buttons_${tab} #control_tab_prompt`)?.click();\n document.getElementById('control_nav')?.click();\n });\n appendContextMenuOption(`#${tab}_tabitem #control_tab`, 'Transfer all parameters to Images tab', () => {\n document.querySelector(`#image_buttons_${tab} #control_tab_params`)?.click();\n document.getElementById('control_nav')?.click();\n });\n }\n addContextMenuEventListener();\n}\n", "import { gradioApp } from './script';\n\nexport function uiOpenSubmenus() {\n const accordions = Array.from(gradioApp().querySelectorAll('.gradio-accordion'));\n const states: Record = {};\n accordions.forEach((el) => {\n const labelEl = el.querySelector('.label-wrap > span:not(.icon)');\n const name = labelEl instanceof HTMLElement ? labelEl.innerText.trim() : '';\n if (!name) return;\n const children = Array.from(el.childNodes);\n const open = children.filter((c) => c instanceof HTMLElement && c.style.display === 'block');\n if (states[name] === undefined) states[name] = open.length > 0;\n });\n return states;\n}\n\nexport async function getUIDefaults() {\n const btn = gradioApp().getElementById('ui_defaults_view');\n if (!btn) return;\n const intersectionObserver = new IntersectionObserver((entries) => {\n if (entries[0].intersectionRatio <= 0) { /* Pass */ }\n if (entries[0].intersectionRatio > 0) btn.click();\n });\n intersectionObserver.observe(btn); // monitor visibility of tab\n}\n\nwindow.uiOpenSubmenus = uiOpenSubmenus;\n", "import { error, log, xhrPost } from './logger';\nimport { authFetch } from './authWrap';\nimport { timer } from './timers';\n\nexport const appStartTime = performance.now();\nlet monitorLogActive = false;\n\nasync function preloadImages(): Promise {\n const dark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;\n const imagePromises: Promise[] = [];\n const num = Math.floor(9.99 * Math.random());\n const imageUrls = [\n `file=ui/assets/logo-bg-${dark ? 'dark' : 'light'}.jpg`,\n `file=ui/assets/logo-bg-${num}.jpg`,\n ];\n for (const url of imageUrls) {\n const img = new Image();\n const promise = new Promise((resolve, reject) => {\n img.onload = () => resolve();\n img.onerror = () => reject(new Error(`failed to preload image: ${url}`));\n });\n img.src = url;\n imagePromises.push(promise);\n }\n try {\n await Promise.all(imagePromises);\n return true;\n } catch (err) {\n error(`preloadImages: ${err}`);\n return false;\n }\n}\n\nfunction joinArgs(messages: unknown[]): string {\n let output = '';\n for (let i = 0; i < messages.length; i++) {\n let arg = messages[i];\n if (arg === undefined) arg = 'undefined';\n if (arg === null) arg = 'null';\n output += ' ';\n if (typeof arg === 'object') output += JSON.stringify(arg).replace(/[\"]+/g, '');\n else output += arg;\n }\n return output;\n}\n\nfunction monitorLog(): void {\n if (window.logBufferDirty) {\n window.logBufferDirty = false;\n const maxLines = 100; // print last n logs from ring buffer to splash-log\n const lines: string[] = [];\n // print last n logs from ring buffer in time order\n for (let i = Math.max(0, window.logRingBuffer.length - maxLines); i < window.logRingBuffer.length; i++) {\n const logEntry = window.logRingBuffer[i];\n let color = 'white';\n if (logEntry.type === 'error') color = 'palevioletred';\n else if (logEntry.type === 'debug') color = 'gray';\n const html = `
    ${logEntry.ts}   ${joinArgs(logEntry.msg)}
    `;\n lines.push(html);\n }\n const splashLogEl = document.getElementById('splashLog');\n if (splashLogEl) splashLogEl.innerHTML = lines.join('');\n }\n if (monitorLogActive) setTimeout(monitorLog, 250);\n}\n\nexport async function removeSplash() {\n const splash = document.getElementById('splash');\n if (splash) splash.remove();\n log('removeSplash');\n const t = Math.round(performance.now() - appStartTime);\n log('startupTime', t);\n timer('splashVisible', t);\n xhrPost(`${window.api}/log`, { message: `ready time=${t}` });\n monitorLogActive = false;\n}\n\nasync function createSplash() {\n const dark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;\n log('createSplash', { theme: dark ? 'dark' : 'light' });\n const num = Math.floor(9.99 * Math.random());\n const splash = `\n
    \n
    \n
    \n
    \n
    `;\n document.body.insertAdjacentHTML('beforeend', splash);\n const ok = await preloadImages();\n if (!ok) {\n removeSplash();\n return;\n }\n const imgEl = `
    `;\n const splashEl = document.getElementById('splash');\n if (splashEl) splashEl.insertAdjacentHTML('afterbegin', imgEl);\n\n monitorLogActive = true;\n monitorLog();\n\n await authFetch(`${window.api}/motd`)\n .then((res) => res.text())\n .then((text) => {\n const clean = text.replace(/[\"]+/g, '');\n const boldMatch = clean.match(/(.*?)<\\/b>/);\n const boldText = boldMatch ? boldMatch[1] : clean;\n if (boldMatch) log('getMOTD', { version: boldText });\n else log('getMOTD', { text: clean });\n const motdEl = document.getElementById('motd');\n if (motdEl) motdEl.innerHTML = clean;\n })\n .catch((err) => error(`getMOTD: ${err}`));\n\n log('loadGradioUi');\n}\n\nwindow.onload = createSplash;\n", "import { log } from './logger';\n\nexport function addLegacyNotice() {\n log('legacyNotice');\n const notice = document.createElement('div');\n notice.id = 'legacy-notice';\n notice.className = 'legacy-standard';\n notice.textContent = 'Legacy';\n notice.title = 'Standard UI is a legacy interface that is no longer maintained and will be removed in the future. Please switch to ModernUI for best experience.';\n document.body.appendChild(notice);\n}\n", "import { initChangelog } from './changelog';\nimport { setupControlUI } from './control';\nimport { initiGenerationParams } from './generationParams';\nimport { initDragDrop } from './imageParams';\nimport { initAccordions } from './inputAccordion';\nimport { initIndexDB } from './indexdb';\nimport { initLogMonitor } from './logMonitor';\nimport { monitorConnection } from './monitor';\nimport { setRefreshInterval } from './progressBar';\nimport { initPromptChecker } from './promptChecker';\nimport { initModels, initSettings } from './settings';\nimport { initGallery } from './gallery';\nimport { initImageViewer } from './imageViewer';\nimport { reconnectUI } from './ui';\nimport { setupExtraNetworks, showNetworks, applyStyles } from './extraNetworks';\nimport { initAutocomplete } from './autocomplete';\nimport { setHints, disconnectHintsObserver } from './setHints';\nimport { initContextMenu } from './contextMenus';\nimport { executeCallbacks, onUiLoaded, onUiReady, sleep, uiReadyCallbacks, initTableSorter } from './script';\nimport { timer, logTimers } from './timers';\nimport { getUIDefaults } from './uiConfig';\nimport { log } from './logger';\nimport { appStartTime, removeSplash } from './loader';\nimport { addLegacyNotice } from './legacy';\n\nwindow.api = '/sdapi/v1';\nwindow.subpath = '';\n\nconst startupPromises: Promise[] = [];\nlet ok = false;\n\nasync function waitForOpts() {\n // make sure all of the ui is ready and options are loaded\n const t0 = performance.now();\n let t1 = performance.now();\n while (true) {\n if (t1 - t0 > 120000) {\n log('waitForOpts timeout');\n break;\n }\n if (window.opts && Object.keys(window.opts).length > 0) {\n ok = window.opts.theme_type === 'Modern' ? 'uiux_separator_appearance' in window.opts : true;\n if (ok) {\n log('waitForOpts', Math.round(t1 - t0));\n timer('waitForOpts', t1 - t0);\n break;\n }\n }\n await sleep(100);\n t1 = performance.now();\n }\n}\n\nasync function postStartup() {\n log('postStartup');\n disconnectHintsObserver();\n logTimers();\n}\n\nasync function updateSubpath() {\n log('mountURL', window.opts.subpath);\n if (window.opts.subpath?.length > 0) {\n window.subpath = window.opts.subpath;\n window.api = `${window.subpath}/sdapi/v1`;\n }\n log('API', { url: window.api });\n}\n\nasync function initStartup() {\n const t0 = performance.now();\n log('initGradio', Math.round(t0 - appStartTime));\n timer('initGradio', t0 - appStartTime);\n log('initUi');\n if (window.setupLogger) await window.setupLogger();\n\n // all items here are non-blocking async calls\n\n startupPromises.push(initModels());\n startupPromises.push(getUIDefaults());\n startupPromises.push(initPromptChecker());\n startupPromises.push(initContextMenu());\n startupPromises.push(initDragDrop());\n startupPromises.push(Promise.resolve(initAccordions()));\n startupPromises.push(Promise.resolve(initSettings()));\n startupPromises.push(Promise.resolve(initImageViewer()));\n startupPromises.push(Promise.resolve(initGallery()));\n startupPromises.push(Promise.resolve(initiGenerationParams()));\n startupPromises.push(Promise.resolve(initChangelog()));\n startupPromises.push(Promise.resolve(setupControlUI()));\n\n // reconnect server session\n await reconnectUI();\n await waitForOpts();\n await updateSubpath();\n\n executeCallbacks(uiReadyCallbacks);\n\n // optionally wait for modern ui\n if (window.waitForUiReady) await window.waitForUiReady();\n\n // post startup tasks that may take longer but are not critical\n startupPromises.push(Promise.resolve(initLogMonitor()));\n startupPromises.push(Promise.resolve(initGallery()));\n startupPromises.push(Promise.resolve(setRefreshInterval()));\n startupPromises.push(Promise.resolve(setupExtraNetworks()));\n startupPromises.push(Promise.resolve(initAutocomplete()));\n startupPromises.push(Promise.resolve(monitorConnection()));\n startupPromises.push(Promise.resolve(showNetworks()));\n startupPromises.push(Promise.resolve(setHints()));\n startupPromises.push(Promise.resolve(applyStyles()));\n startupPromises.push(Promise.resolve(initIndexDB()));\n startupPromises.push(Promise.resolve(initTableSorter()));\n\n if (window.opts.theme_type !== 'Modern') addLegacyNotice();\n\n const t1 = performance.now();\n log('initStartup', Math.round(1000 * (t1 - t0) / 1000000));\n\n removeSplash();\n\n await Promise.all(startupPromises);\n const t2 = performance.now();\n log('initComplete', Math.round(1000 * (t2 - t0) / 1000000));\n postStartup();\n}\n\nonUiLoaded(initStartup);\nonUiReady(() => log('uiReady'));\n\n// onAfterUiUpdate(() => log('evt onAfterUiUpdate'));\n// onUiLoaded(() => log('evt onUiLoaded'));\n// onOptionsChanged(() => log('evt onOptionsChanged'));\n// onUiTabChange(() => log('evt onUiTabChange'));\n// onUiUpdate(() => log('evt onUiUpdate'));\n", "import { randomId } from './progressBar';\n\nimport { log } from './logger';\nimport { gradioApp } from './script';\nimport { restartReload, updateInput } from './ui';\n\nexport function extensions_apply(_extensionsDisabledList: unknown, _extensionsUpdateList: unknown, disableAll: unknown): [string, string, unknown] {\n const disable = [];\n const update = [];\n gradioApp().querySelectorAll('#extensions input[type=\"checkbox\"]').forEach((x) => {\n if (!(x instanceof HTMLInputElement)) return;\n if (x.name.startsWith('enable_') && !x.checked) disable.push(x.name.substring(7));\n if (x.name.startsWith('update_') && x.checked) update.push(x.name.substring(7));\n });\n restartReload();\n log('Extensions apply:', { disable, update });\n return [JSON.stringify(disable), JSON.stringify(update), disableAll];\n}\n\nexport function extensions_check(_info: unknown, _extensionsDisabledList: unknown, searchText: unknown, sortColumn: unknown): [string, string, unknown, unknown] {\n const disable = [];\n gradioApp().querySelectorAll('#extensions input[type=\"checkbox\"]').forEach((x) => {\n if (!(x instanceof HTMLInputElement)) return;\n if (x.name.startsWith('enable_') && !x.checked) disable.push(x.name.substring(7));\n });\n const id = randomId();\n log('Extensions check:', { disable });\n return [id, JSON.stringify(disable), searchText, sortColumn];\n}\n\nexport function install_extension(button: HTMLButtonElement | HTMLInputElement, url: string): void {\n button.disabled = true;\n button.value = 'Installing...';\n button.innerHTML = 'installing';\n const textarea = gradioApp().querySelector('#extension_to_install textarea');\n if (!(textarea instanceof HTMLTextAreaElement)) return;\n textarea.value = url;\n updateInput(textarea);\n log('Extension install:', { url });\n const installBtn = gradioApp().querySelector('#install_extension_button');\n if (installBtn instanceof HTMLElement) installBtn.click();\n}\n\nexport function uninstall_extension(button: HTMLButtonElement | HTMLInputElement, url: string): void {\n button.disabled = true;\n button.value = 'Uninstalling...';\n button.innerHTML = 'uninstalling';\n const textarea = gradioApp().querySelector('#extension_to_install textarea');\n if (!(textarea instanceof HTMLTextAreaElement)) return;\n textarea.value = url;\n updateInput(textarea);\n log('Extension uninstall:', { url });\n const uninstallBtn = gradioApp().querySelector('#uninstall_extension_button');\n if (uninstallBtn instanceof HTMLElement) uninstallBtn.click();\n}\n\nexport function update_extension(button: HTMLButtonElement | HTMLInputElement, url: string): void {\n button.value = 'Updating...';\n button.innerHTML = 'updating';\n const textarea = gradioApp().querySelector('#extension_to_install textarea');\n if (!(textarea instanceof HTMLTextAreaElement)) return;\n textarea.value = url;\n updateInput(textarea);\n log('Extension update:', { url });\n const updateBtn = gradioApp().querySelector('#update_extension_button');\n if (updateBtn instanceof HTMLInputElement) updateBtn.click();\n}\n\nwindow.extensions_apply = extensions_apply;\nwindow.extensions_check = extensions_check;\nwindow.uninstall_extension = uninstall_extension;\nwindow.install_extension = install_extension;\nwindow.update_extension = update_extension;\n", "import { log } from './logger';\nimport { gradioApp, uiElementIsVisible, uiElementInSight } from './script';\n\ntype PromptDropTarget = EventTarget & {\n placeholder?: string;\n closest: (selector: string) => Element | null;\n};\n\nfunction isValidImageList(files: FileList | null | undefined): files is FileList {\n return files && files?.length === 1 && ['image/png', 'image/gif', 'image/jpeg'].includes(files[0].type);\n}\n\nfunction dropReplaceImage(imgWrap: Element, files: FileList): void {\n log('dropReplaceImage', imgWrap, files);\n if (!isValidImageList(files)) return;\n const tmpFile = files[0];\n imgWrap.querySelector('.modify-upload button + button, .touch-none + div button + button')?.click();\n const callback = () => {\n const fileInput = imgWrap.querySelector('input[type=\"file\"]');\n if (fileInput instanceof HTMLInputElement) {\n if (files.length === 0) {\n const dt = new DataTransfer();\n dt.items.add(tmpFile);\n fileInput.files = dt.files;\n } else {\n fileInput.files = files;\n }\n fileInput.dispatchEvent(new Event('change'));\n }\n };\n\n if (imgWrap.closest('#pnginfo_image')) {\n const oldFetch = window.fetch;\n window.fetch = async (input: RequestInfo | URL, options?: RequestInit) => {\n const response = await oldFetch(input, options);\n if (input === 'api/predict/') {\n const content = await response.text();\n window.fetch = oldFetch;\n window.requestAnimationFrame(() => callback());\n return new Response(content, {\n status: response.status,\n statusText: response.statusText,\n headers: response.headers,\n });\n }\n return response;\n };\n } else {\n window.requestAnimationFrame(() => callback());\n }\n}\n\nwindow.document.addEventListener('dragover', (e) => {\n const target = e.composedPath()[0] as PromptDropTarget;\n const imgWrap = target.closest('[data-testid=\"image\"]');\n if (!imgWrap && target.placeholder && target.placeholder.indexOf('Prompt') === -1) return;\n if ((e.dataTransfer?.files?.length || 0) > 0) {\n e.stopPropagation();\n e.preventDefault();\n e.dataTransfer.dropEffect = 'copy';\n }\n});\n\nwindow.document.addEventListener('drop', (e) => {\n const target = e.composedPath()[0] as PromptDropTarget;\n log('dropEvent', e, target);\n if (!target.placeholder) return;\n if (target.placeholder.indexOf('Prompt') === -1) return;\n const imgWrap = target.closest('[data-testid=\"image\"]');\n if (!imgWrap) return;\n if ((e.dataTransfer?.files?.length || 0) > 0) {\n e.stopPropagation();\n e.preventDefault();\n dropReplaceImage(imgWrap, e.dataTransfer.files);\n }\n});\n\nwindow.addEventListener('paste', (e) => {\n log('pasteEvent', e);\n const files = e.clipboardData?.files;\n if (!isValidImageList(files)) return;\n const visibleImageFields = [...gradioApp().querySelectorAll('[data-testid=\"image\"]')]\n .filter((el) => uiElementIsVisible(el))\n .sort((a, b) => Number(uiElementInSight(b)) - Number(uiElementInSight(a)));\n if (!visibleImageFields.length) return;\n const firstFreeImageField = visibleImageFields.filter((el) => el.querySelector('input[type=file]'))?.[0];\n dropReplaceImage(firstFreeImageField || visibleImageFields[visibleImageFields.length - 1], files);\n});\n", "import { gradioApp, onUiLoaded } from './script';\nimport { log, error } from './logger';\nimport { authFetch } from './authWrap';\n\ninterface CivitFile {\n url?: string;\n name?: string;\n type?: string;\n size?: number;\n}\n\ninterface CivitImage {\n url: string;\n}\n\ninterface CivitVersion {\n id: number;\n name?: string;\n base?: string;\n mtime: string;\n availability?: string;\n desc?: string;\n files: CivitFile[];\n images: CivitImage[];\n}\n\ninterface CivitModel {\n id: number;\n url: string;\n name?: string;\n type?: string;\n tags?: string[];\n nsfw?: boolean;\n level?: number;\n availability?: string;\n downloads?: number;\n creator?: string;\n desc?: string;\n versions: CivitVersion[];\n}\n\n// eslint-disable-next-line no-extend-native\nString.prototype.format = function format(this: string, args: Record): string {\n let thisString = '';\n for (let charPos = 0; charPos < this.length; charPos++) thisString += this[charPos];\n for (const key in args) {\n const stringKey = `{${key}}`;\n thisString = thisString.replace(new RegExp(stringKey, 'g'), String(args[key]));\n }\n return thisString;\n};\n\nlet selectedURL: string[] = [];\nlet selectedName: string[] = [];\nlet selectedType: string[] = [];\nlet selectedBase: string[] = [];\nlet selectedModelId: number[] = [];\nlet selectedVersionId: number[] = [];\n\nexport function clearModelDetails() {\n const el = gradioApp().getElementById('model-details') || gradioApp().getElementById('civitai_models_output') || gradioApp().getElementById('models_outcome');\n if (!el) return;\n el.innerHTML = '';\n}\nwindow.clearModelDetails = clearModelDetails;\n\nconst modelDetailsHTML = `\n
    \n \"model\n \n \n \n \n \n \n \n \n \n \n \n
    Name{name}
    Type{type}
    Tags
    {tags}
    NSFW{nsfw} | {level}
    Availability{availability}
    Downloads{downloads}
    Author{creator}
    Description
    {desc}
    Download
    All variants
    \n
    \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n {versions}\n \n
    VersionTypeBaseFileUpdatedSizeAvailabilityDescription
    \n
    \n`;\n\nconst modelVersionsHTML = `\n \n {url}\n {name}\n {type}\n {base}\n {file}\n {mtime}\n {size}\n {availability}\n
    {desc}
    \n \n`;\n\nexport async function modelCardClick(id) {\n log('modelCardClick id', id);\n const el = gradioApp().getElementById('model-details') || gradioApp().getElementById('civitai_models_output') || gradioApp().getElementById('models_outcome');\n if (!el) return;\n const res = await authFetch(`${window.api}/civitai?model_id=${encodeURI(id)}`);\n if (!res || res.status !== 200) {\n error(`modelCardClick: id=${id} status=${res ? res.status : 'unknown'}`);\n return;\n }\n const dataArray = await res.json();\n log('modelCardClick data', dataArray);\n if (!dataArray || dataArray.length === 0) return;\n const data: any = dataArray[0]; // assuming the first item is the one we want\n\n const versionsHTML = data.versions.map((v: CivitVersion) => modelVersionsHTML.format({\n url: `
    \\udb80\\uddda
    `,\n name: v.name || 'unknown',\n type: v.files[0]?.type || 'unknown',\n base: v.base || 'unknown',\n mtime: (new Date(v.mtime)).toLocaleDateString(),\n availability: v.availability || 'unknown',\n size: v.files[0]?.size ? `${(v.files[0].size / 1024 / 1024).toFixed(2)} MB` : 'unknown',\n file: `${v.files[0]?.name || 'unknown'}`,\n desc: v.desc || 'no description available',\n })).join('');\n const url = `${data.name || 'unknown'}`;\n const creator = `${data.creator || 'unknown'}`;\n const images = data.versions.map((v: CivitVersion) => v.images).flat().map((i: CivitImage) => i.url); // TODO image gallery\n const modelHTML = modelDetailsHTML.format({\n name: url,\n type: data.type || 'unknown',\n tags: data.tags?.join(', ') || '',\n nsfw: data.nsfw ? 'yes' : 'no',\n level: data.level?.toString() || '',\n availability: data.availability || 'unknown',\n downloads: data.downloads?.toString() || '',\n creator,\n desc: data.desc || 'no description available',\n image: images.length > 0 ? images[0] : '/sdapi/v1/network/thumb?filename=ui/assets/missing.png',\n versions: versionsHTML || '',\n });\n el.innerHTML = modelHTML;\n}\nwindow.modelCardClick = modelCardClick;\n\nexport function startCivitDownload(url, name, type, base, modelId, versionId) {\n log('startCivitDownload', { url, name, type, base, modelId, versionId });\n selectedURL = [url];\n selectedName = [name];\n selectedType = [type];\n selectedBase = [base || ''];\n selectedModelId = [modelId || 0];\n selectedVersionId = [versionId || 0];\n const civitDownloadBtn = gradioApp().getElementById('civitai_download_btn');\n if (civitDownloadBtn) civitDownloadBtn.click();\n}\nwindow.startCivitDownload = startCivitDownload;\n\nexport function startCivitAllDownload(evt) {\n log('startCivitAllDownload', evt);\n const table = gradioApp().getElementById('model-versions-table');\n if (!table) return;\n const versions = table.querySelectorAll('tr');\n selectedURL = [];\n selectedName = [];\n selectedType = [];\n selectedBase = [];\n selectedModelId = [];\n selectedVersionId = [];\n for (const version of versions) {\n const parsed = version.querySelector('td:nth-child(1) div')?.getAttribute('onclick')?.match(/startCivitDownload\\('([^']+)', '([^']+)', '([^']+)', '([^']*)', (\\d+), (\\d+)\\)/);\n if (!parsed || parsed.length < 7) continue;\n selectedURL.push(parsed[1]);\n selectedName.push(parsed[2]);\n selectedType.push(parsed[3]);\n selectedBase.push(parsed[4]);\n selectedModelId.push(parseInt(parsed[5], 10));\n selectedVersionId.push(parseInt(parsed[6], 10));\n }\n const civitDownloadBtn = gradioApp().getElementById('civitai_download_btn');\n if (civitDownloadBtn) civitDownloadBtn.click();\n}\nwindow.startCivitAllDownload = startCivitAllDownload;\n\nexport function downloadCivitModel(modelUrl, modelName, modelType, modelBase, mId, vId, modelPath, civitToken, innerHTML) {\n log('downloadCivitModel', { modelUrl, modelName, modelType, modelBase, mId, vId, modelPath, civitToken });\n const el = gradioApp().getElementById('civitai_models_output') || gradioApp().getElementById('models_outcome');\n const currentHTML = el?.innerHTML || '';\n return [selectedURL, selectedName, selectedType, selectedBase, selectedModelId, selectedVersionId, modelPath, civitToken, currentHTML];\n}\nwindow.downloadCivitModel = downloadCivitModel;\n\nlet civitMutualExcludeBound = false;\n\nexport function civitaiMutualExclude() {\n if (civitMutualExcludeBound) return;\n const searchEl = gradioApp().querySelector('#civit_search_text textarea');\n const tagEl = gradioApp().querySelector('#civit_search_tag textarea');\n if (!searchEl || !tagEl) return;\n civitMutualExcludeBound = true;\n searchEl.addEventListener('input', () => {\n tagEl.closest('.gradio-textbox')?.classList.toggle('disabled-look', !!searchEl.value.trim());\n });\n tagEl.addEventListener('input', () => {\n searchEl.closest('.gradio-textbox')?.classList.toggle('disabled-look', !!tagEl.value.trim());\n });\n}\n\nonUiLoaded(civitaiMutualExclude);\n", "import { log } from './logger';\n\ntype GuiderLike = string | { label?: string };\n\nconst guiders: Record = {\n None: '',\n 'LSC: LayerSkipConfig': 'https://github.com/huggingface/diffusers/blob/041501aea92919c9c7f36e189fc9cf7d865ebb96/src/diffusers/hooks/layer_skip.py#L41',\n 'CFG: ClassifierFreeGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.ClassifierFreeGuidance',\n 'Auto: AutoGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.AutoGuidance',\n 'Zero: ClassifierFreeZeroStar': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.ClassifierFreeZeroStarGuidance',\n 'PAG: PerturbedAttentionGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.PerturbedAttentionGuidance',\n 'APG: AdaptiveProjectedGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.AdaptiveProjectedGuidance',\n 'SLG: SkipLayerGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.SkipLayerGuidance',\n 'SEG: SmoothedEnergyGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.SmoothedEnergyGuidance',\n 'TCFG: TangentialClassifierFreeGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.TangentialClassifierFreeGuidance',\n 'FDG: FrequencyDecoupledGuidance': 'https://huggingface.co/docs/diffusers/v0.35.1/en/api/modular_diffusers/guiders#diffusers.FrequencyDecoupledGuidance',\n};\n\nexport function getGuidanceDocs(guider: GuiderLike): void {\n const key = typeof guider === 'object' && guider?.label ? guider.label : guider;\n const url = guiders[key as string];\n log('getGuidanceDocs', guider, url);\n if (url) window.open(url, '_blank');\n}\n\nwindow.getGuidanceDocs = getGuidanceDocs;\n", "/* eslint max-classes-per-file: [\"error\", 2] */\n\ninterface TimesheetItem {\n start: number;\n end: number;\n label: string;\n type: string;\n}\n\nclass Bubble {\n type: string;\n label: string;\n min: number;\n start: number;\n end: number;\n scale: number;\n offset: number;\n width: number;\n duration: number;\n title: string;\n\n constructor(min: number, start: number, end: number, label: string, scale: number, type: string) {\n this.type = type;\n this.label = label;\n this.min = min;\n this.start = start;\n this.end = end;\n this.scale = scale;\n this.offset = Math.round(this.scale * (this.start - this.min));\n this.width = Math.round(this.scale * (this.end - this.start));\n this.duration = Math.round(1000 * (this.end - this.start)) / 1000;\n this.title = `Job: ${this.label}\\nDuration: ${this.duration}s\\nStart: ${new Date(1000 * this.start).toLocaleString()}\\nEnd: ${new Date(1000 * this.end).toLocaleString()}`;\n }\n\n getDateLabel(): number {\n return Math.round(1000 * (this.end - this.start)) / 1000;\n }\n}\n\nexport class Timesheet {\n min: number;\n max: number;\n data: TimesheetItem[];\n container: HTMLElement;\n scale: number;\n\n constructor(container: HTMLElement, data: TimesheetItem[]) {\n this.min = Math.floor(data[0].start);\n this.max = Math.round(data[data.length - 1].end + 0.5);\n this.data = data;\n this.container = container;\n const box = container.getBoundingClientRect();\n const width = box.width - 140;\n this.scale = width / (this.max - this.min);\n\n // draw sections\n let html: string[] = [];\n for (let c = 0; c <= this.max - this.min; c++) html.push(`
    `);\n container.className = 'timesheet color-scheme-default';\n container.innerHTML = `
    ${html.join('')}
    `;\n\n // insert data\n html = [];\n for (let n = 0, m = this.data.length; n < m; n++) {\n const cur = this.data[n];\n const bubble = new Bubble(this.min, cur.start, cur.end, cur.label, this.scale, cur.type);\n const line = [\n ``,\n `${bubble.duration} `,\n `${bubble.label}`,\n ].join('');\n html.push(`
  • ${line}
    • `);\n }\n this.container.innerHTML += `
      ${html.join('')}
    `;\n }\n}\n", "import { Timesheet } from './timesheet';\nimport { log } from './logger';\nimport { authFetch } from './authWrap';\n\ninterface HistoryEntry {\n timestamp: number;\n id: string;\n job: string;\n op: string;\n duration?: number;\n outputs: string[];\n type?: 'inference' | 'io' | 'default';\n}\n\ninterface TimelineEntry {\n start: number;\n end: number;\n label: string;\n type: 'inference' | 'io' | 'default';\n}\n\nconst inferenceTypes = ['inference', 'vae', 'te'];\nconst ioTypes = ['load', 'save'];\n\nexport function refreshHistory() {\n log('refreshHistory');\n authFetch(`${window.api}/history`, { priority: 'low' }).then((res) => {\n if (!res) return;\n const timeline = document.getElementById('history_timeline');\n const table = document.getElementById('history_table');\n if (!timeline || !table) return;\n timeline.innerHTML = '';\n res.json().then((rawData) => {\n let data = rawData as HistoryEntry[];\n if (!data || !data.length) {\n table.innerHTML = '

    No history data available.

    ';\n return;\n }\n\n // build table\n let html = '';\n for (const entry of data) {\n const ts = new Date(1000 * entry.timestamp).toLocaleString();\n const duration = entry.duration ? (entry.duration).toFixed(3) : '';\n const outputs = entry.outputs.join(', ');\n html += ``;\n }\n html += '
    TimeIDJobActionDurationOutputs
    ${ts}${entry.id}${entry.job}${entry.op}${duration}${outputs}
    ';\n table.innerHTML = html;\n\n // crop data to last processing session\n let startIdx = -1;\n for (let i = data.length - 1; i >= 0; --i) {\n const e = data[i];\n if ((e.job === 'control' || e.job === 'text' || e.job === 'control' || e.job === 'image') && (e.op === 'begin')) {\n startIdx = i;\n break;\n }\n }\n if (startIdx >= 0) data = data.slice(startIdx);\n\n // build timeline\n const ts: TimelineEntry[] = [];\n for (const entry of data) {\n if (entry.op === 'begin') {\n const start = entry.timestamp;\n const endEntry = data.find((e) => (e.id === entry.id && e.op === 'end'));\n const end = endEntry?.timestamp ?? data[data.length - 1].timestamp;\n if (end - start < 0.02) continue; // skip very short entries\n if (inferenceTypes.some((type) => entry.job.toLowerCase().startsWith(type))) entry.type = 'inference';\n else if (ioTypes.some((type) => entry.job.toLowerCase().startsWith(type))) entry.type = 'io';\n else entry.type = 'default';\n if (start && end) ts.push({ start, end, label: entry.job, type: entry.type });\n }\n }\n if (!ts.length) return;\n // eslint-disable-next-line no-new\n new Timesheet(timeline, ts);\n });\n });\n}\n\nwindow.refreshHistory = refreshHistory;\n", "import { gradioApp, onAfterUiUpdate } from './script';\nimport { get_tab_index } from './ui';\n\nlet currentWidth: number | null = null;\nlet currentHeight: number | null = null;\nlet arFrameTimeout: ReturnType | undefined;\n\nfunction dimensionChange(e: Event, isWidth: boolean, isHeight: boolean): void {\n const { target } = e;\n if (!(target instanceof HTMLInputElement)) return;\n if (isWidth) currentWidth = Number(target.value);\n if (isHeight) currentHeight = Number(target.value);\n const tabImg2img = gradioApp().querySelector('#tab_img2img');\n if (!(tabImg2img instanceof HTMLElement)) return;\n const inImg2img = tabImg2img.style.display === 'block';\n if (!inImg2img) return;\n let targetElement: HTMLImageElement | null = null;\n const tabIndex = get_tab_index('mode_img2img');\n if (tabIndex === 0) targetElement = gradioApp().querySelector('#img2img_image div[data-testid=image] img'); // img2img\n else if (tabIndex === 1) targetElement = gradioApp().querySelector('#img2img_sketch div[data-testid=image] img'); // Sketch\n else if (tabIndex === 2) targetElement = gradioApp().querySelector('#img2maskimg div[data-testid=image] img'); // Inpaint\n else if (tabIndex === 3) targetElement = gradioApp().querySelector('#composite div[data-testid=image] img'); // Inpaint sketch\n\n if (targetElement && currentWidth && currentHeight) {\n let arPreviewRect = gradioApp().querySelector('#imageARPreview');\n if (!arPreviewRect) {\n arPreviewRect = document.createElement('div');\n arPreviewRect.id = 'imageARPreview';\n gradioApp().appendChild(arPreviewRect);\n }\n\n const viewportOffset = targetElement.getBoundingClientRect();\n const viewportscale = Math.min(targetElement.clientWidth / targetElement.naturalWidth, targetElement.clientHeight / targetElement.naturalHeight);\n const scaledx = targetElement.naturalWidth * viewportscale;\n const scaledy = targetElement.naturalHeight * viewportscale;\n const cleintRectTop = (viewportOffset.top + window.scrollY);\n const cleintRectLeft = (viewportOffset.left + window.scrollX);\n const cleintRectCentreY = cleintRectTop + (targetElement.clientHeight / 2);\n const cleintRectCentreX = cleintRectLeft + (targetElement.clientWidth / 2);\n const arscale = Math.min(scaledx / currentWidth, scaledy / currentHeight);\n const arscaledx = currentWidth * arscale;\n const arscaledy = currentHeight * arscale;\n const arRectTop = cleintRectCentreY - (arscaledy / 2);\n const arRectLeft = cleintRectCentreX - (arscaledx / 2);\n const arRectWidth = arscaledx;\n const arRectHeight = arscaledy;\n arPreviewRect.style.top = `${arRectTop}px`;\n arPreviewRect.style.left = `${arRectLeft}px`;\n arPreviewRect.style.width = `${arRectWidth}px`;\n arPreviewRect.style.height = `${arRectHeight}px`;\n\n if (arFrameTimeout) clearTimeout(arFrameTimeout);\n arFrameTimeout = setTimeout(() => { arPreviewRect.style.display = 'none'; }, 2000);\n arPreviewRect.style.display = 'block';\n }\n}\n\nexport function aspectRatioCallback(): void {\n const arPreviewRect = gradioApp().querySelector('#imageARPreview');\n if (arPreviewRect instanceof HTMLElement) arPreviewRect.style.display = 'none';\n const tabImg2img = gradioApp().querySelector('#tab_img2img');\n if (tabImg2img instanceof HTMLElement) {\n const inImg2img = tabImg2img.style.display === 'block';\n if (inImg2img) {\n const inputs = gradioApp().querySelectorAll('input');\n inputs.forEach((e) => {\n if (!(e instanceof HTMLInputElement) || !(e.parentElement instanceof HTMLElement)) return;\n const isWidth = e.parentElement.id === 'img2img_width';\n const isHeight = e.parentElement.id === 'img2img_height';\n if ((isWidth || isHeight) && !e.classList.contains('scrollwatch')) {\n e.addEventListener('input', (evt) => { dimensionChange(evt, isWidth, isHeight); });\n e.classList.add('scrollwatch');\n }\n if (isWidth) currentWidth = Number(e.value);\n if (isHeight) currentHeight = Number(e.value);\n });\n }\n }\n}\n\nonAfterUiUpdate(aspectRatioCallback);\n", "import { gradioApp, onAfterUiUpdate } from './script';\n\n// Aspect-ratio lock for the paired width/height sliders. The math runs client-side and debounced,\n// and only the partner axis is ever written, never the field being edited; writing the edited field\n// back is what yanked the value mid-type when this went through a gradio round-trip. Programmatic\n// updates dispatch a synthetic input event so gradio's store stays in sync. State is keyed per\n// dropdown element so duplicate elem ids across tabs stay isolated.\n\nconst RES_DEBOUNCE = 350;\nconst AR_DEBOUNCE = 120;\nconst timers = new WeakMap>();\nconst busy = new WeakSet();\n\nfunction parseAR(ar: string): [number, number] | null {\n if (!ar || ar === 'AR') return null;\n const parts = ar.split(':');\n if (parts.length !== 2) return null;\n const w = parseInt(parts[0], 10);\n const h = parseInt(parts[1], 10);\n return (w > 0 && h > 0) ? [w, h] : null;\n}\n\nfunction numberInput(group: Element): HTMLInputElement | null {\n const inp = group.querySelector('input[type=number]') || group.querySelector('input');\n return inp instanceof HTMLInputElement ? inp : null;\n}\n\nfunction readValue(group: Element): number {\n const inp = numberInput(group);\n return inp ? Number(inp.value) : 0;\n}\n\nfunction writeValue(group: Element, raw: number): void {\n const inp = numberInput(group);\n if (!inp) return;\n const step = Number(inp.step) || 8;\n const min = inp.min !== '' ? Number(inp.min) : 0;\n const max = inp.max !== '' ? Number(inp.max) : 8192;\n const value = Math.max(min, Math.min(max, Math.round(raw / step) * step));\n if (value === Number(inp.value)) return; // unchanged: skip so the listeners do not refire\n group.querySelectorAll('input').forEach((el) => {\n if (!(el instanceof HTMLInputElement)) return;\n el.value = String(value);\n const e = new Event('input', { bubbles: true });\n Object.defineProperty(e, 'target', { value: el });\n el.dispatchEvent(e);\n });\n}\n\nfunction arValue(arEl: Element): string {\n const inp = arEl.querySelector('input');\n return inp instanceof HTMLInputElement ? inp.value : 'AR';\n}\n\nfunction pairOf(arEl: Element): { width: Element; height: Element } | null {\n let container: Element | null = arEl.parentElement;\n for (let i = 0; i < 6 && container; i++) {\n const width = container.querySelector('[id$=\"_width\"]');\n const height = container.querySelector('[id$=\"_height\"]');\n if (width && height) return { width, height };\n container = container.parentElement;\n }\n return null;\n}\n\nfunction settle(arEl: Element, source: 'width' | 'height'): void {\n const ar = parseAR(arValue(arEl));\n if (!ar) return;\n const pair = pairOf(arEl);\n if (!pair) return;\n const [rw, rh] = ar;\n busy.add(arEl);\n if (source === 'height') writeValue(pair.width, (readValue(pair.height) * rw) / rh);\n else writeValue(pair.height, (readValue(pair.width) * rh) / rw);\n busy.delete(arEl);\n}\n\nfunction schedule(arEl: Element, source: 'width' | 'height', delay: number): void {\n if (busy.has(arEl)) return; // ignore the input events our own writes dispatch\n clearTimeout(timers.get(arEl));\n timers.set(arEl, setTimeout(() => settle(arEl, source), delay));\n}\n\nfunction flush(arEl: Element, source: 'width' | 'height'): void {\n if (busy.has(arEl)) return;\n clearTimeout(timers.get(arEl));\n settle(arEl, source);\n}\n\nfunction bind(arEl: Element, group: Element, source: 'width' | 'height'): void {\n group.querySelectorAll('input').forEach((el) => {\n if (!(el instanceof HTMLInputElement) || el.classList.contains('ar-lock-bound')) return;\n el.classList.add('ar-lock-bound');\n el.addEventListener('input', () => schedule(arEl, source, RES_DEBOUNCE));\n el.addEventListener('change', () => flush(arEl, source)); // commit on blur, enter, or slider release\n });\n}\n\nexport function setupResolutionLock(): void {\n gradioApp().querySelectorAll('.ar-dropdown').forEach((arEl) => {\n const pair = pairOf(arEl);\n if (!pair) return;\n bind(arEl, pair.width, 'width');\n bind(arEl, pair.height, 'height');\n arEl.querySelectorAll('input').forEach((el) => {\n if (!(el instanceof HTMLInputElement) || el.classList.contains('ar-lock-bound')) return;\n el.classList.add('ar-lock-bound');\n el.addEventListener('change', () => flush(arEl, 'width')); // new ratio: keep width, derive height\n el.addEventListener('input', () => schedule(arEl, 'width', AR_DEBOUNCE));\n });\n });\n}\n\nonAfterUiUpdate(setupResolutionLock);\n", "import { updateInput } from './ui';\n\nexport function keyupEditAttention(event: KeyboardEvent): void {\n const target = (event as any).originalTarget || event.composedPath()[0];\n if (!(target instanceof HTMLTextAreaElement)) return;\n if (!target.matches(\"*:is([id*='_toprow'] [id*='_prompt'], .prompt) textarea\")) return;\n if (!(event.metaKey || event.ctrlKey)) return;\n const isPlus = event.key === 'ArrowUp';\n const isMinus = event.key === 'ArrowDown';\n if (!isPlus && !isMinus) return;\n let { selectionStart } = target;\n let { selectionEnd } = target;\n let text = target.value;\n\n function selectCurrentParenthesisBlock(OPEN: string, CLOSE: string): boolean {\n if (selectionStart !== selectionEnd) return false;\n\n // Find opening parenthesis around current cursor\n const before = text.substring(0, selectionStart);\n let beforeParen = before.lastIndexOf(OPEN);\n if (beforeParen === -1) return false;\n let beforeParenClose = before.lastIndexOf(CLOSE);\n while (beforeParenClose !== -1 && beforeParenClose > beforeParen) {\n beforeParen = before.lastIndexOf(OPEN, beforeParen - 1);\n beforeParenClose = before.lastIndexOf(CLOSE, beforeParenClose - 1);\n }\n\n // Find closing parenthesis around current cursor\n const after = text.substring(selectionStart);\n let afterParen = after.indexOf(CLOSE);\n if (afterParen === -1) return false;\n let afterParenOpen = after.indexOf(OPEN);\n while (afterParenOpen !== -1 && afterParen > afterParenOpen) {\n afterParen = after.indexOf(CLOSE, afterParen + 1);\n afterParenOpen = after.indexOf(OPEN, afterParenOpen + 1);\n }\n if (beforeParen === -1 || afterParen === -1) return false;\n\n // Set the selection to the text between the parenthesis\n const parenContent = text.substring(beforeParen + 1, selectionStart + afterParen);\n const lastColon = parenContent.lastIndexOf(':');\n selectionStart = beforeParen + 1;\n selectionEnd = selectionStart + lastColon;\n target.setSelectionRange(selectionStart, selectionEnd);\n return true;\n }\n\n function selectCurrentWord(): boolean {\n if (selectionStart !== selectionEnd) return false;\n const delimiters = `${window.opts.keyedit_delimiters} \\r\\n\\t`;\n // seek backward until to find beginning\n while (!delimiters.includes(text[selectionStart - 1]) && selectionStart > 0) selectionStart--;\n // seek forward to find end\n while (!delimiters.includes(text[selectionEnd]) && selectionEnd < text.length) selectionEnd++;\n target.setSelectionRange(selectionStart, selectionEnd);\n return true;\n }\n\n // If the user hasn't selected anything, let's select their current parenthesis block or word\n if (!selectCurrentParenthesisBlock('<', '>') && !selectCurrentParenthesisBlock('(', ')')) selectCurrentWord();\n event.preventDefault();\n\n let closeCharacter = ')';\n let delta = window.opts.keyedit_precision_attention;\n\n if (selectionStart > 0 && text[selectionStart - 1] === '<') {\n closeCharacter = '>';\n delta = window.opts.keyedit_precision_extra;\n } else if (selectionStart === 0 || text[selectionStart - 1] !== '(') {\n while (selectionEnd > selectionStart && text[selectionEnd - 1] === ' ') selectionEnd -= 1;\n if (selectionStart === selectionEnd) return;\n text = `${text.slice(0, selectionStart)}(${text.slice(selectionStart, selectionEnd)}:1.0)${text.slice(selectionEnd)}`;\n selectionStart += 1;\n selectionEnd += 1;\n }\n const end = text.slice(selectionEnd + 1).indexOf(closeCharacter) + 1;\n let weight: any = parseFloat(text.slice(selectionEnd + 1, selectionEnd + 1 + end));\n if (Number.isNaN(weight)) return;\n weight += isPlus ? delta : -delta;\n weight = parseFloat(weight.toPrecision(12));\n if (String(weight).length === 1) weight += '.0';\n if (closeCharacter === ')' && weight === 1) {\n text = text.slice(0, selectionStart - 1) + text.slice(selectionStart, selectionEnd) + text.slice(selectionEnd + 5);\n selectionStart--;\n selectionEnd--;\n } else {\n text = text.slice(0, selectionEnd + 1) + weight + text.slice(selectionEnd + 1 + end - 1);\n }\n target.focus();\n target.value = text;\n target.selectionStart = selectionStart;\n target.selectionEnd = selectionEnd;\n updateInput(target);\n}\n\naddEventListener('keydown', (event) => keyupEditAttention(event));\n", "/**\n*\n* jquery.sparkline.js\n*\n* v2.4.1\n* (c) Splunk, Inc\n* Contact: Gareth Watts (gareth@splunk.com)\n* http://omnipotent.net/jquery.sparkline/\n*\n* Generates inline sparkline charts from data supplied either to the method\n* or inline in HTML\n*\n* Compatible with Internet Explorer 6.0+ and modern browsers equipped with the canvas tag\n* (Firefox 2.0+, Safari, Opera, etc)\n*\n* License: New BSD License\n*\n* Copyright (c) 2012, Splunk Inc.\n* All rights reserved.\n*\n* Redistribution and use in source and binary forms, with or without modification,\n* are permitted provided that the following conditions are met:\n*\n* * Redistributions of source code must retain the above copyright notice,\n* this list of conditions and the following disclaimer.\n* * Redistributions in binary form must reproduce the above copyright notice,\n* this list of conditions and the following disclaimer in the documentation\n* and/or other materials provided with the distribution.\n* * Neither the name of Splunk Inc nor the names of its contributors may\n* be used to endorse or promote products derived from this software without\n* specific prior written permission.\n*\n* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY\n* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT\n* SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT\n* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*\n*\n* Usage:\n* $(selector).sparkline(values, options)\n*\n* If values is undefined or set to 'html' then the data values are read from the specified tag:\n*

    Sparkline: 1,4,6,6,8,5,3,5

    \n* $('.sparkline').sparkline();\n* There must be no spaces in the enclosed data set\n*\n* Otherwise values must be an array of numbers or null values\n*

    Sparkline: This text replaced if the browser is compatible

    \n* $('#sparkline1').sparkline([1,4,6,6,8,5,3,5])\n* $('#sparkline2').sparkline([1,4,6,null,null,5,3,5])\n*\n* Values can also be specified in an HTML comment, or as a values attribute:\n*

    Sparkline:

    \n*

    Sparkline:

    \n* $('.sparkline').sparkline();\n*\n* For line charts, x values can also be specified:\n*

    Sparkline: 1:1,2.7:4,3.4:6,5:6,6:8,8.7:5,9:3,10:5

    \n* $('#sparkline1').sparkline([ [1,1], [2.7,4], [3.4,6], [5,6], [6,8], [8.7,5], [9,3], [10,5] ])\n*\n* By default, options should be passed in as the second argument to the sparkline function:\n* $('.sparkline').sparkline([1,2,3,4], {type: 'bar'})\n*\n* Options can also be set by passing them on the tag itself. This feature is disabled by default though\n* as there's a slight performance overhead:\n* $('.sparkline').sparkline([1,2,3,4], {enableTagOptions: true})\n*

    Sparkline: loading

    \n* Prefix all options supplied as tag attribute with \"spark\" (configurable by setting tagOptionsPrefix)\n*\n* Supported options:\n* lineColor - Color of the line used for the chart\n* fillColor - Color used to fill in the chart - Set to '' or false for a transparent chart\n* width - Width of the chart - Defaults to 3 times the number of values in pixels\n* height - Height of the chart - Defaults to the height of the containing element\n* chartRangeMin - Specify the minimum value to use for the Y range of the chart - Defaults to the minimum value supplied\n* chartRangeMax - Specify the maximum value to use for the Y range of the chart - Defaults to the maximum value supplied\n* chartRangeClip - Clip out of range values to the max/min specified by chartRangeMin and chartRangeMax\n* chartRangeMinX - Specify the minimum value to use for the X range of the chart - Defaults to the minimum value supplied\n* chartRangeMaxX - Specify the maximum value to use for the X range of the chart - Defaults to the maximum value supplied\n* composite - If true then don't erase any existing chart attached to the tag, but draw\n* another chart over the top - Note that width and height are ignored if an\n* existing chart is detected.\n* tagValuesAttribute - Name of tag attribute to check for data values - Defaults to 'values'\n* enableTagOptions - Whether to check tags for sparkline options\n* tagOptionsPrefix - Prefix used for options supplied as tag attributes - Defaults to 'spark'\n* disableHiddenCheck - If set to true, then the plugin will assume that charts will never be drawn into a\n* hidden dom element, avoding a browser reflow\n* disableInteraction - If set to true then all mouseover/click interaction behaviour will be disabled,\n* making the plugin perform much like it did in 1.x\n* disableTooltips - If set to true then tooltips will be disabled - Defaults to false (tooltips enabled)\n* disableHighlight - If set to true then highlighting of selected chart elements on mouseover will be disabled\n* defaults to false (highlights enabled)\n* highlightLighten - Factor to lighten/darken highlighted chart values by - Defaults to 1.4 for a 40% increase\n* tooltipContainer - Specify which DOM element the tooltip should be rendered into - defaults to document.body\n* tooltipClassname - Optional CSS classname to apply to tooltips - If not specified then a default style will be applied\n* tooltipOffsetX - How many pixels away from the mouse pointer to render the tooltip on the X axis\n* tooltipOffsetY - How many pixels away from the mouse pointer to render the tooltip on the r axis\n* tooltipFormatter - Optional callback that allows you to override the HTML displayed in the tooltip\n* callback is given arguments of (sparkline, options, fields)\n* tooltipChartTitle - If specified then the tooltip uses the string specified by this setting as a title\n* tooltipFormat - A format string or SPFormat object (or an array thereof for multiple entries)\n* to control the format of the tooltip\n* tooltipPrefix - A string to prepend to each field displayed in a tooltip\n* tooltipSuffix - A string to append to each field displayed in a tooltip\n* tooltipSkipNull - If true then null values will not have a tooltip displayed (defaults to true)\n* tooltipValueLookups - An object or range map to map field values to tooltip strings\n* (eg. to map -1 to \"Lost\", 0 to \"Draw\", and 1 to \"Win\")\n* numberFormatter - Optional callback for formatting numbers in tooltips\n* numberDigitGroupSep - Character to use for group separator in numbers \"1,234\" - Defaults to \",\"\n* numberDecimalMark - Character to use for the decimal point when formatting numbers - Defaults to \".\"\n* numberDigitGroupCount - Number of digits between group separator - Defaults to 3\n*\n* There are 7 types of sparkline, selected by supplying a \"type\" option of 'line' (default),\n* 'bar', 'tristate', 'bullet', 'discrete', 'pie' or 'box'\n* line - Line chart. Options:\n* spotColor - Set to '' to not end each line in a circular spot\n* minSpotColor - If set, color of spot at minimum value\n* maxSpotColor - If set, color of spot at maximum value\n* spotRadius - Radius in pixels\n* lineWidth - Width of line in pixels\n* normalRangeMin\n* normalRangeMax - If set draws a filled horizontal bar between these two values marking the \"normal\"\n* or expected range of values\n* normalRangeColor - Color to use for the above bar\n* drawNormalOnTop - Draw the normal range above the chart fill color if true\n* defaultPixelsPerValue - Defaults to 3 pixels of width for each value in the chart\n* highlightSpotColor - The color to use for drawing a highlight spot on mouseover - Set to null to disable\n* highlightLineColor - The color to use for drawing a highlight line on mouseover - Set to null to disable\n* valueSpots - Specify which points to draw spots on, and in which color. Accepts a range map\n*\n* bar - Bar chart. Options:\n* barColor - Color of bars for postive values\n* negBarColor - Color of bars for negative values\n* zeroColor - Color of bars with zero values\n* nullColor - Color of bars with null values - Defaults to omitting the bar entirely\n* barWidth - Width of bars in pixels\n* colorMap - Optional mappnig of values to colors to override the *BarColor values above\n* can be an Array of values to control the color of individual bars or a range map\n* to specify colors for individual ranges of values\n* barSpacing - Gap between bars in pixels\n* zeroAxis - Centers the y-axis around zero if true\n*\n* tristate - Charts values of win (>0), lose (<0) or draw (=0)\n* posBarColor - Color of win values\n* negBarColor - Color of lose values\n* zeroBarColor - Color of draw values\n* barWidth - Width of bars in pixels\n* barSpacing - Gap between bars in pixels\n* colorMap - Optional mappnig of values to colors to override the *BarColor values above\n* can be an Array of values to control the color of individual bars or a range map\n* to specify colors for individual ranges of values\n*\n* discrete - Options:\n* lineHeight - Height of each line in pixels - Defaults to 30% of the graph height\n* thesholdValue - Values less than this value will be drawn using thresholdColor instead of lineColor\n* thresholdColor\n*\n* bullet - Values for bullet graphs msut be in the order: target, performance, range1, range2, range3, ...\n* options:\n* targetColor - The color of the vertical target marker\n* targetWidth - The width of the target marker in pixels\n* performanceColor - The color of the performance measure horizontal bar\n* rangeColors - Colors to use for each qualitative range background color\n*\n* pie - Pie chart. Options:\n* sliceColors - An array of colors to use for pie slices\n* offset - Angle in degrees to offset the first slice - Try -90 or +90\n* borderWidth - Width of border to draw around the pie chart, in pixels - Defaults to 0 (no border)\n* borderColor - Color to use for the pie chart border - Defaults to #000\n*\n* box - Box plot. Options:\n* raw - Set to true to supply pre-computed plot points as values\n* values should be: low_outlier, low_whisker, q1, median, q3, high_whisker, high_outlier\n* When set to false you can supply any number of values and the box plot will\n* be computed for you. Default is false.\n* showOutliers - Set to true (default) to display outliers as circles\n* outlierIQR - Interquartile range used to determine outliers. Default 1.5\n* boxLineColor - Outline color of the box\n* boxFillColor - Fill color for the box\n* whiskerColor - Line color used for whiskers\n* outlierLineColor - Outline color of outlier circles\n* outlierFillColor - Fill color of the outlier circles\n* spotRadius - Radius of outlier circles\n* medianColor - Line color of the median line\n* target - Draw a target cross hair at the supplied value (default undefined)\n*\n*\n*\n* Examples:\n* $('#sparkline1').sparkline(myvalues, { lineColor: '#f00', fillColor: false });\n* $('.barsparks').sparkline('html', { type:'bar', height:'40px', barWidth:5 });\n* $('#tristate').sparkline([1,1,-1,1,0,0,-1], { type:'tristate' }):\n* $('#discrete').sparkline([1,3,4,5,5,3,4,5], { type:'discrete' });\n* $('#bullet').sparkline([10,12,12,9,7], { type:'bullet' });\n* $('#pie').sparkline([1,1,2], { type:'pie' });\n*/\n\n/*jslint regexp: true, browser: true, jquery: true, white: true, nomen: false, plusplus: false, maxerr: 500, indent: 4 */\n\n(function(document, Math, undefined) { // performance/minified-size optimization\n(function(factory) {\n if(typeof define === 'function' && define.amd) {\n define(['jquery'], factory);\n } else if (jQuery && !jQuery.fn.sparkline) {\n factory(jQuery);\n }\n}\n(function($) {\n 'use strict';\n\n var UNSET_OPTION = {},\n getDefaults, createClass, SPFormat, clipval, quartile, normalizeValue, normalizeValues,\n remove, isNumber, all, sum, addCSS, ensureArray, formatNumber, RangeMap,\n MouseHandler, Tooltip, barHighlightMixin,\n line, bar, tristate, discrete, bullet, pie, box, defaultStyles, initStyles,\n VShape, VCanvas_base, VCanvas_canvas, VCanvas_vml, pending, shapeCount = 0;\n\n /**\n * Default configuration settings\n */\n getDefaults = function () {\n return {\n // Settings common to most/all chart types\n common: {\n type: 'line',\n lineColor: '#00f',\n fillColor: '#cdf',\n defaultPixelsPerValue: 3,\n width: 'auto',\n height: 'auto',\n composite: false,\n tagValuesAttribute: 'values',\n tagOptionsPrefix: 'spark',\n enableTagOptions: false,\n enableHighlight: true,\n highlightLighten: 1.4,\n tooltipSkipNull: true,\n tooltipPrefix: '',\n tooltipSuffix: '',\n disableHiddenCheck: false,\n numberFormatter: false,\n numberDigitGroupCount: 3,\n numberDigitGroupSep: ',',\n numberDecimalMark: '.',\n disableTooltips: false,\n disableInteraction: false\n },\n // Defaults for line charts\n line: {\n spotColor: '#f80',\n highlightSpotColor: '#5f5',\n highlightLineColor: '#f22',\n spotRadius: 1.5,\n minSpotColor: '#f80',\n maxSpotColor: '#f80',\n lineWidth: 1,\n normalRangeMin: undefined,\n normalRangeMax: undefined,\n normalRangeColor: '#ccc',\n drawNormalOnTop: false,\n chartRangeMin: undefined,\n chartRangeMax: undefined,\n chartRangeMinX: undefined,\n chartRangeMaxX: undefined,\n tooltipFormat: new SPFormat('● {{prefix}}{{y}}{{suffix}}')\n },\n // Defaults for bar charts\n bar: {\n barColor: '#3366cc',\n negBarColor: '#f44',\n stackedBarColor: ['#3366cc', '#dc3912', '#ff9900', '#109618', '#66aa00',\n '#dd4477', '#0099c6', '#990099'],\n zeroColor: undefined,\n nullColor: undefined,\n zeroAxis: true,\n barWidth: 4,\n barSpacing: 1,\n chartRangeMax: undefined,\n chartRangeMin: undefined,\n chartRangeClip: false,\n colorMap: undefined,\n tooltipFormat: new SPFormat('● {{prefix}}{{value}}{{suffix}}')\n },\n // Defaults for tristate charts\n tristate: {\n barWidth: 4,\n barSpacing: 1,\n posBarColor: '#6f6',\n negBarColor: '#f44',\n zeroBarColor: '#999',\n colorMap: {},\n tooltipFormat: new SPFormat('● {{value:map}}'),\n tooltipValueLookups: { map: { '-1': 'Loss', '0': 'Draw', '1': 'Win' } }\n },\n // Defaults for discrete charts\n discrete: {\n lineHeight: 'auto',\n thresholdColor: undefined,\n thresholdValue: 0,\n chartRangeMax: undefined,\n chartRangeMin: undefined,\n chartRangeClip: false,\n tooltipFormat: new SPFormat('{{prefix}}{{value}}{{suffix}}')\n },\n // Defaults for bullet charts\n bullet: {\n targetColor: '#f33',\n targetWidth: 3, // width of the target bar in pixels\n performanceColor: '#33f',\n rangeColors: ['#d3dafe', '#a8b6ff', '#7f94ff'],\n base: undefined, // set this to a number to change the base start number\n tooltipFormat: new SPFormat('{{fieldkey:fields}} - {{value}}'),\n tooltipValueLookups: { fields: {r: 'Range', p: 'Performance', t: 'Target'} }\n },\n // Defaults for pie charts\n pie: {\n offset: 0,\n sliceColors: ['#3366cc', '#dc3912', '#ff9900', '#109618', '#66aa00',\n '#dd4477', '#0099c6', '#990099'],\n borderWidth: 0,\n borderColor: '#000',\n tooltipFormat: new SPFormat('● {{value}} ({{percent.1}}%)')\n },\n // Defaults for box plots\n box: {\n raw: false,\n boxLineColor: '#000',\n boxFillColor: '#cdf',\n whiskerColor: '#000',\n outlierLineColor: '#333',\n outlierFillColor: '#fff',\n medianColor: '#f00',\n showOutliers: true,\n outlierIQR: 1.5,\n spotRadius: 1.5,\n target: undefined,\n targetColor: '#4a2',\n chartRangeMax: undefined,\n chartRangeMin: undefined,\n tooltipFormat: new SPFormat('{{field:fields}}: {{value}}'),\n tooltipFormatFieldlistKey: 'field',\n tooltipValueLookups: { fields: { lq: 'Lower Quartile', med: 'Median',\n uq: 'Upper Quartile', lo: 'Left Outlier', ro: 'Right Outlier',\n lw: 'Left Whisker', rw: 'Right Whisker'} }\n }\n };\n };\n\n // You can have tooltips use a css class other than jqstooltip by specifying tooltipClassname\n defaultStyles = '.jqstooltip { ' +\n 'position: absolute;' +\n 'left: 0px;' +\n 'top: 0px;' +\n 'visibility: hidden;' +\n 'background: rgb(0, 0, 0) transparent;' +\n 'background-color: rgba(0,0,0,0.6);' +\n 'filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#99000000, endColorstr=#99000000);' +\n '-ms-filter: \"progid:DXImageTransform.Microsoft.gradient(startColorstr=#99000000, endColorstr=#99000000)\";' +\n 'color: white;' +\n 'font: 10px arial, san serif;' +\n 'text-align: left;' +\n 'white-space: nowrap;' +\n 'padding: 5px;' +\n 'border: 1px solid white;' +\n 'box-sizing: content-box;' +\n 'z-index: 10000;' +\n '}' +\n '.jqsfield { ' +\n 'color: white;' +\n 'font: 10px arial, san serif;' +\n 'text-align: left;' +\n '}';\n\n /**\n * Utilities\n */\n\n createClass = function (/* [baseclass, [mixin, ...]], definition */) {\n var Class, args;\n Class = function () {\n this.init.apply(this, arguments);\n };\n if (arguments.length > 1) {\n if (arguments[0]) {\n Class.prototype = $.extend(new arguments[0](), arguments[arguments.length - 1]);\n Class._super = arguments[0].prototype;\n } else {\n Class.prototype = arguments[arguments.length - 1];\n }\n if (arguments.length > 2) {\n args = Array.prototype.slice.call(arguments, 1, -1);\n args.unshift(Class.prototype);\n $.extend.apply($, args);\n }\n } else {\n Class.prototype = arguments[0];\n }\n Class.prototype.cls = Class;\n return Class;\n };\n\n /**\n * Wraps a format string for tooltips\n * {{x}}\n * {{x.2}\n * {{x:months}}\n */\n $.SPFormatClass = SPFormat = createClass({\n fre: /\\{\\{([\\w.]+?)(:(.+?))?\\}\\}/g,\n precre: /(\\w+)\\.(\\d+)/,\n\n init: function (format, fclass) {\n this.format = format;\n this.fclass = fclass;\n },\n\n render: function (fieldset, lookups, options) {\n var self = this,\n fields = fieldset,\n match, token, lookupkey, fieldvalue, prec;\n return this.format.replace(this.fre, function () {\n var lookup;\n token = arguments[1];\n lookupkey = arguments[3];\n match = self.precre.exec(token);\n if (match) {\n prec = match[2];\n token = match[1];\n } else {\n prec = false;\n }\n fieldvalue = fields[token];\n if (fieldvalue === undefined) {\n return '';\n }\n if (lookupkey && lookups && lookups[lookupkey]) {\n lookup = lookups[lookupkey];\n if (lookup.get) { // RangeMap\n return lookups[lookupkey].get(fieldvalue) || fieldvalue;\n } else {\n return lookups[lookupkey][fieldvalue] || fieldvalue;\n }\n }\n if (isNumber(fieldvalue)) {\n if (options.get('numberFormatter')) {\n fieldvalue = options.get('numberFormatter')(fieldvalue);\n } else {\n fieldvalue = formatNumber(fieldvalue, prec,\n options.get('numberDigitGroupCount'),\n options.get('numberDigitGroupSep'),\n options.get('numberDecimalMark'));\n }\n }\n return fieldvalue;\n });\n }\n });\n\n // convience method to avoid needing the new operator\n $.spformat = function(format, fclass) {\n return new SPFormat(format, fclass);\n };\n\n clipval = function (val, min, max) {\n if (val < min) {\n return min;\n }\n if (val > max) {\n return max;\n }\n return val;\n };\n\n quartile = function (values, q) {\n var vl;\n if (q === 2) {\n vl = Math.floor(values.length / 2);\n return values.length % 2 ? values[vl] : (values[vl-1] + values[vl]) / 2;\n } else {\n if (values.length % 2 ) { // odd\n vl = (values.length * q + q) / 4;\n return vl % 1 ? (values[Math.floor(vl)] + values[Math.floor(vl) - 1]) / 2 : values[vl-1];\n } else { //even\n vl = (values.length * q + 2) / 4;\n return vl % 1 ? (values[Math.floor(vl)] + values[Math.floor(vl) - 1]) / 2 : values[vl-1];\n\n }\n }\n };\n\n normalizeValue = function (val) {\n var nf;\n switch (val) {\n case 'undefined':\n val = undefined;\n break;\n case 'null':\n val = null;\n break;\n case 'true':\n val = true;\n break;\n case 'false':\n val = false;\n break;\n default:\n nf = parseFloat(val);\n if (val == nf) {\n val = nf;\n }\n }\n return val;\n };\n\n normalizeValues = function (vals) {\n var i, result = [];\n for (i = vals.length; i--;) {\n result[i] = normalizeValue(vals[i]);\n }\n return result;\n };\n\n remove = function (vals, filter) {\n var i, vl, result = [];\n for (i = 0, vl = vals.length; i < vl; i++) {\n if (vals[i] !== filter) {\n result.push(vals[i]);\n }\n }\n return result;\n };\n\n isNumber = function (num) {\n return !isNaN(parseFloat(num)) && isFinite(num);\n };\n\n formatNumber = function (num, prec, groupsize, groupsep, decsep) {\n var p, i;\n num = (prec === false ? parseFloat(num).toString() : num.toFixed(prec)).split('');\n p = (p = $.inArray('.', num)) < 0 ? num.length : p;\n if (p < num.length) {\n num[p] = decsep;\n }\n for (i = p - groupsize; i > 0; i -= groupsize) {\n num.splice(i, 0, groupsep);\n }\n return num.join('');\n };\n\n // determine if all values of an array match a value\n // returns true if the array is empty\n all = function (val, arr, ignoreNull) {\n var i;\n for (i = arr.length; i--; ) {\n if (ignoreNull && arr[i] === null) continue;\n if (arr[i] !== val) {\n return false;\n }\n }\n return true;\n };\n\n // sums the numeric values in an array, ignoring other values\n sum = function (vals) {\n var total = 0, i;\n for (i = vals.length; i--;) {\n total += typeof vals[i] === 'number' ? vals[i] : 0;\n }\n return total;\n };\n\n ensureArray = function (val) {\n return $.isArray(val) ? val : [val];\n };\n\n // http://paulirish.com/2008/bookmarklet-inject-new-css-rules/\n addCSS = function(css) {\n var tag, iefail;\n if (document.createStyleSheet) {\n try {\n document.createStyleSheet().cssText = css;\n return;\n } catch (e) {\n // IE <= 9 maxes out at 31 stylesheets; inject into page instead.\n iefail = true;\n }\n }\n tag = document.createElement('style');\n tag.type = 'text/css';\n document.getElementsByTagName('head')[0].appendChild(tag);\n if (iefail) {\n document.styleSheets[document.styleSheets.length - 1].cssText = css;\n } else {\n tag[(typeof document.body.style.WebkitAppearance == 'string') /* webkit only */ ? 'innerText' : 'innerHTML'] = css;\n }\n };\n\n // Provide a cross-browser interface to a few simple drawing primitives\n $.fn.simpledraw = function (width, height, useExisting, interact) {\n var target, mhandler;\n if (useExisting && (target = this.data('_jqs_vcanvas'))) {\n return target;\n }\n\n if ($.fn.sparkline.canvas === false) {\n // We've already determined that neither Canvas nor VML are available\n return false;\n\n } else if ($.fn.sparkline.canvas === undefined) {\n // No function defined yet -- need to see if we support Canvas or VML\n var el = document.createElement('canvas');\n if (!!(el.getContext && el.getContext('2d'))) {\n // Canvas is available\n $.fn.sparkline.canvas = function(width, height, target, interact) {\n return new VCanvas_canvas(width, height, target, interact);\n };\n } else if (document.namespaces && !document.namespaces.v) {\n // VML is available\n document.namespaces.add('v', 'urn:schemas-microsoft-com:vml', '#default#VML');\n $.fn.sparkline.canvas = function(width, height, target, interact) {\n return new VCanvas_vml(width, height, target);\n };\n } else {\n // Neither Canvas nor VML are available\n $.fn.sparkline.canvas = false;\n return false;\n }\n }\n\n if (width === undefined) {\n width = $(this).innerWidth();\n }\n if (height === undefined) {\n height = $(this).innerHeight();\n }\n\n target = $.fn.sparkline.canvas(width, height, this, interact);\n\n mhandler = $(this).data('_jqs_mhandler');\n if (mhandler) {\n mhandler.registerCanvas(target);\n }\n return target;\n };\n\n $.fn.cleardraw = function () {\n var target = this.data('_jqs_vcanvas');\n if (target) {\n target.reset();\n }\n };\n\n $.RangeMapClass = RangeMap = createClass({\n init: function (map) {\n var key, range, rangelist = [];\n for (key in map) {\n if (map.hasOwnProperty(key) && typeof key === 'string' && key.indexOf(':') > -1) {\n range = key.split(':');\n range[0] = range[0].length === 0 ? -Infinity : parseFloat(range[0]);\n range[1] = range[1].length === 0 ? Infinity : parseFloat(range[1]);\n range[2] = map[key];\n rangelist.push(range);\n }\n }\n this.map = map;\n this.rangelist = rangelist || false;\n },\n\n get: function (value) {\n var rangelist = this.rangelist,\n i, range, result;\n if ((result = this.map[value]) !== undefined) {\n return result;\n }\n if (rangelist) {\n for (i = rangelist.length; i--;) {\n range = rangelist[i];\n if (range[0] <= value && range[1] >= value) {\n return range[2];\n }\n }\n }\n return undefined;\n }\n });\n\n // Convenience function\n $.range_map = function(map) {\n return new RangeMap(map);\n };\n\n MouseHandler = createClass({\n init: function (el, options) {\n var $el = $(el);\n this.$el = $el;\n this.options = options;\n this.currentPageX = 0;\n this.currentPageY = 0;\n this.el = el;\n this.splist = [];\n this.tooltip = null;\n this.over = false;\n this.displayTooltips = !options.get('disableTooltips');\n this.highlightEnabled = !options.get('disableHighlight');\n },\n\n registerSparkline: function (sp) {\n this.splist.push(sp);\n if (this.over) {\n this.updateDisplay();\n }\n },\n\n registerCanvas: function (canvas) {\n var $canvas = $(canvas.canvas);\n this.canvas = canvas;\n this.$canvas = $canvas;\n $canvas.mouseenter($.proxy(this.mouseenter, this));\n $canvas.mouseleave($.proxy(this.mouseleave, this));\n $canvas.click($.proxy(this.mouseclick, this));\n },\n\n reset: function (removeTooltip) {\n this.splist = [];\n if (this.tooltip && removeTooltip) {\n this.tooltip.remove();\n this.tooltip = undefined;\n }\n },\n\n mouseclick: function (e) {\n var clickEvent = $.Event('sparklineClick');\n clickEvent.originalEvent = e;\n clickEvent.sparklines = this.splist;\n this.$el.trigger(clickEvent);\n },\n\n mouseenter: function (e) {\n $(document.body).unbind('mousemove.jqs');\n $(document.body).bind('mousemove.jqs', $.proxy(this.mousemove, this));\n this.over = true;\n this.currentPageX = e.pageX;\n this.currentPageY = e.pageY;\n this.currentEl = e.target;\n if (!this.tooltip && this.displayTooltips) {\n this.tooltip = new Tooltip(this.options);\n this.tooltip.updatePosition(e.pageX, e.pageY);\n }\n this.updateDisplay();\n },\n\n mouseleave: function () {\n $(document.body).unbind('mousemove.jqs');\n var splist = this.splist,\n spcount = splist.length,\n needsRefresh = false,\n sp, i;\n this.over = false;\n this.currentEl = null;\n\n if (this.tooltip) {\n this.tooltip.remove();\n this.tooltip = null;\n }\n\n for (i = 0; i < spcount; i++) {\n sp = splist[i];\n if (sp.clearRegionHighlight()) {\n needsRefresh = true;\n }\n }\n\n if (needsRefresh) {\n this.canvas.render();\n }\n },\n\n mousemove: function (e) {\n this.currentPageX = e.pageX;\n this.currentPageY = e.pageY;\n this.currentEl = e.target;\n if (this.tooltip) {\n this.tooltip.updatePosition(e.pageX, e.pageY);\n }\n this.updateDisplay();\n },\n\n updateDisplay: function () {\n var splist = this.splist,\n spcount = splist.length,\n needsRefresh = false,\n offset = this.$canvas.offset(),\n localX = this.currentPageX - offset.left,\n localY = this.currentPageY - offset.top,\n tooltiphtml, sp, i, result, changeEvent;\n if (!this.over) {\n return;\n }\n for (i = 0; i < spcount; i++) {\n sp = splist[i];\n result = sp.setRegionHighlight(this.currentEl, localX, localY);\n if (result) {\n needsRefresh = true;\n }\n }\n if (needsRefresh) {\n changeEvent = $.Event('sparklineRegionChange');\n changeEvent.sparklines = this.splist;\n this.$el.trigger(changeEvent);\n if (this.tooltip) {\n tooltiphtml = '';\n for (i = 0; i < spcount; i++) {\n sp = splist[i];\n tooltiphtml += sp.getCurrentRegionTooltip();\n }\n this.tooltip.setContent(tooltiphtml);\n }\n if (!this.disableHighlight) {\n this.canvas.render();\n }\n }\n if (result === null) {\n this.mouseleave();\n }\n }\n });\n\n\n Tooltip = createClass({\n sizeStyle: 'position: static !important;' +\n 'display: block !important;' +\n 'visibility: hidden !important;' +\n 'float: left !important;',\n\n init: function (options) {\n var tooltipClassname = options.get('tooltipClassname', 'jqstooltip'),\n sizetipStyle = this.sizeStyle,\n offset;\n this.container = options.get('tooltipContainer') || document.body;\n this.tooltipOffsetX = options.get('tooltipOffsetX', 10);\n this.tooltipOffsetY = options.get('tooltipOffsetY', 12);\n // remove any previous lingering tooltip\n $('#jqssizetip').remove();\n $('#jqstooltip').remove();\n this.sizetip = $('
    ', {\n id: 'jqssizetip',\n style: sizetipStyle,\n 'class': tooltipClassname\n });\n this.tooltip = $('
    ', {\n id: 'jqstooltip',\n 'class': tooltipClassname\n }).appendTo(this.container);\n // account for the container's location\n offset = this.tooltip.offset();\n this.offsetLeft = offset.left;\n this.offsetTop = offset.top;\n this.hidden = true;\n $(window).unbind('resize.jqs scroll.jqs');\n $(window).bind('resize.jqs scroll.jqs', $.proxy(this.updateWindowDims, this));\n this.updateWindowDims();\n },\n\n updateWindowDims: function () {\n this.scrollTop = $(window).scrollTop();\n this.scrollLeft = $(window).scrollLeft();\n this.scrollRight = this.scrollLeft + $(window).width();\n this.updatePosition();\n },\n\n getSize: function (content) {\n this.sizetip.html(content).appendTo(this.container);\n this.width = this.sizetip.width() + 1;\n this.height = this.sizetip.height();\n this.sizetip.remove();\n },\n\n setContent: function (content) {\n if (!content) {\n this.tooltip.css('visibility', 'hidden');\n this.hidden = true;\n return;\n }\n this.getSize(content);\n this.tooltip.html(content)\n .css({\n 'width': this.width,\n 'height': this.height,\n 'visibility': 'visible'\n });\n if (this.hidden) {\n this.hidden = false;\n this.updatePosition();\n }\n },\n\n updatePosition: function (x, y) {\n if (x === undefined) {\n if (this.mousex === undefined) {\n return;\n }\n x = this.mousex - this.offsetLeft;\n y = this.mousey - this.offsetTop;\n\n } else {\n this.mousex = x = x - this.offsetLeft;\n this.mousey = y = y - this.offsetTop;\n }\n if (!this.height || !this.width || this.hidden) {\n return;\n }\n\n y -= this.height + this.tooltipOffsetY;\n x += this.tooltipOffsetX;\n\n if (y < this.scrollTop) {\n y = this.scrollTop;\n }\n if (x < this.scrollLeft) {\n x = this.scrollLeft;\n } else if (x + this.width > this.scrollRight) {\n x = this.scrollRight - this.width;\n }\n\n this.tooltip.css({\n 'left': x,\n 'top': y\n });\n },\n\n remove: function () {\n this.tooltip.remove();\n this.sizetip.remove();\n this.sizetip = this.tooltip = undefined;\n $(window).unbind('resize.jqs scroll.jqs');\n }\n });\n\n initStyles = function() {\n addCSS(defaultStyles);\n };\n\n $(initStyles);\n\n pending = [];\n $.fn.sparkline = function (userValues, userOptions) {\n return this.each(function () {\n var options = new $.fn.sparkline.options(this, userOptions),\n $this = $(this),\n render, i;\n render = function () {\n var values, width, height, tmp, mhandler, sp, vals;\n if (userValues === 'html' || userValues === undefined) {\n vals = this.getAttribute(options.get('tagValuesAttribute'));\n if (vals === undefined || vals === null) {\n vals = $this.html();\n }\n values = vals.replace(/(^\\s*\\s*$)|\\s+/g, '').split(',');\n } else {\n values = userValues;\n }\n\n width = options.get('width') === 'auto' ? values.length * options.get('defaultPixelsPerValue') : options.get('width');\n if (options.get('height') === 'auto') {\n if (!options.get('composite') || !$.data(this, '_jqs_vcanvas')) {\n // must be a better way to get the line height\n tmp = document.createElement('span');\n tmp.innerHTML = 'a';\n $this.html(tmp);\n height = $(tmp).innerHeight() || $(tmp).height();\n $(tmp).remove();\n tmp = null;\n }\n } else {\n height = options.get('height');\n }\n\n if (!options.get('disableInteraction')) {\n mhandler = $.data(this, '_jqs_mhandler');\n if (!mhandler) {\n mhandler = new MouseHandler(this, options);\n $.data(this, '_jqs_mhandler', mhandler);\n } else if (!options.get('composite')) {\n mhandler.reset();\n }\n } else {\n mhandler = false;\n }\n\n if (options.get('composite') && !$.data(this, '_jqs_vcanvas')) {\n if (!$.data(this, '_jqs_errnotify')) {\n alert('Attempted to attach a composite sparkline to an element with no existing sparkline');\n $.data(this, '_jqs_errnotify', true);\n }\n return;\n }\n\n sp = new $.fn.sparkline[options.get('type')](this, values, options, width, height);\n\n sp.render();\n\n if (mhandler) {\n mhandler.registerSparkline(sp);\n }\n };\n if (($(this).html() && !options.get('disableHiddenCheck') && $(this).is(':hidden')) || !$(this).parents('body').length) {\n if (!options.get('composite') && $.data(this, '_jqs_pending')) {\n // remove any existing references to the element\n for (i = pending.length; i; i--) {\n if (pending[i - 1][0] == this) {\n pending.splice(i - 1, 1);\n }\n }\n }\n pending.push([this, render]);\n $.data(this, '_jqs_pending', true);\n } else {\n render.call(this);\n }\n });\n };\n\n $.fn.sparkline.defaults = getDefaults();\n\n\n $.sparkline_display_visible = function () {\n var el, i, pl;\n var done = [];\n for (i = 0, pl = pending.length; i < pl; i++) {\n el = pending[i][0];\n if ($(el).is(':visible') && !$(el).parents().is(':hidden')) {\n pending[i][1].call(el);\n $.data(pending[i][0], '_jqs_pending', false);\n done.push(i);\n } else if (!$(el).closest('html').length && !$.data(el, '_jqs_pending')) {\n // element has been inserted and removed from the DOM\n // If it was not yet inserted into the dom then the .data request\n // will return true.\n // removing from the dom causes the data to be removed.\n $.data(pending[i][0], '_jqs_pending', false);\n done.push(i);\n }\n }\n for (i = done.length; i; i--) {\n pending.splice(done[i - 1], 1);\n }\n };\n\n\n /**\n * User option handler\n */\n $.fn.sparkline.options = createClass({\n init: function (tag, userOptions) {\n var extendedOptions, defaults, base, tagOptionType;\n this.userOptions = userOptions = userOptions || {};\n this.tag = tag;\n this.tagValCache = {};\n defaults = $.fn.sparkline.defaults;\n base = defaults.common;\n this.tagOptionsPrefix = userOptions.enableTagOptions && (userOptions.tagOptionsPrefix || base.tagOptionsPrefix);\n\n tagOptionType = this.getTagSetting('type');\n if (tagOptionType === UNSET_OPTION) {\n extendedOptions = defaults[userOptions.type || base.type];\n } else {\n extendedOptions = defaults[tagOptionType];\n }\n this.mergedOptions = $.extend({}, base, extendedOptions, userOptions);\n },\n\n\n getTagSetting: function (key) {\n var prefix = this.tagOptionsPrefix,\n val, i, pairs, keyval;\n if (prefix === false || prefix === undefined) {\n return UNSET_OPTION;\n }\n if (this.tagValCache.hasOwnProperty(key)) {\n val = this.tagValCache.key;\n } else {\n val = this.tag.getAttribute(prefix + key);\n if (val === undefined || val === null) {\n val = UNSET_OPTION;\n } else if (val.substr(0, 1) === '[') {\n val = val.substr(1, val.length - 2).split(',');\n for (i = val.length; i--;) {\n val[i] = normalizeValue(val[i].replace(/(^\\s*)|(\\s*$)/g, ''));\n }\n } else if (val.substr(0, 1) === '{') {\n pairs = val.substr(1, val.length - 2).split(',');\n val = {};\n for (i = pairs.length; i--;) {\n keyval = pairs[i].split(':', 2);\n val[keyval[0].replace(/(^\\s*)|(\\s*$)/g, '')] = normalizeValue(keyval[1].replace(/(^\\s*)|(\\s*$)/g, ''));\n }\n } else {\n val = normalizeValue(val);\n }\n this.tagValCache.key = val;\n }\n return val;\n },\n\n get: function (key, defaultval) {\n var tagOption = this.getTagSetting(key),\n result;\n if (tagOption !== UNSET_OPTION) {\n return tagOption;\n }\n return (result = this.mergedOptions[key]) === undefined ? defaultval : result;\n }\n });\n\n\n $.fn.sparkline._base = createClass({\n disabled: false,\n\n init: function (el, values, options, width, height) {\n this.el = el;\n this.$el = $(el);\n this.values = values;\n this.options = options;\n this.width = width;\n this.height = height;\n this.currentRegion = undefined;\n },\n\n /**\n * Setup the canvas\n */\n initTarget: function () {\n var interactive = !this.options.get('disableInteraction');\n if (!(this.target = this.$el.simpledraw(this.width, this.height, this.options.get('composite'), interactive))) {\n this.disabled = true;\n } else {\n this.canvasWidth = this.target.pixelWidth;\n this.canvasHeight = this.target.pixelHeight;\n }\n },\n\n /**\n * Actually render the chart to the canvas\n */\n render: function () {\n if (this.disabled) {\n this.el.innerHTML = '';\n return false;\n }\n return true;\n },\n\n /**\n * Return a region id for a given x/y co-ordinate\n */\n getRegion: function (x, y) {\n },\n\n /**\n * Highlight an item based on the moused-over x,y co-ordinate\n */\n setRegionHighlight: function (el, x, y) {\n var currentRegion = this.currentRegion,\n highlightEnabled = !this.options.get('disableHighlight'),\n newRegion;\n if (x > this.canvasWidth || y > this.canvasHeight || x < 0 || y < 0) {\n return null;\n }\n newRegion = this.getRegion(el, x, y);\n if (currentRegion !== newRegion) {\n if (currentRegion !== undefined && highlightEnabled) {\n this.removeHighlight();\n }\n this.currentRegion = newRegion;\n if (newRegion !== undefined && highlightEnabled) {\n this.renderHighlight();\n }\n return true;\n }\n return false;\n },\n\n /**\n * Reset any currently highlighted item\n */\n clearRegionHighlight: function () {\n if (this.currentRegion !== undefined) {\n this.removeHighlight();\n this.currentRegion = undefined;\n return true;\n }\n return false;\n },\n\n renderHighlight: function () {\n this.changeHighlight(true);\n },\n\n removeHighlight: function () {\n this.changeHighlight(false);\n },\n\n changeHighlight: function (highlight) {},\n\n /**\n * Fetch the HTML to display as a tooltip\n */\n getCurrentRegionTooltip: function () {\n var options = this.options,\n header = '',\n entries = [],\n fields, formats, formatlen, fclass, text, i,\n showFields, showFieldsKey, newFields, fv,\n formatter, format, fieldlen, j;\n if (this.currentRegion === undefined) {\n return '';\n }\n fields = this.getCurrentRegionFields();\n formatter = options.get('tooltipFormatter');\n if (formatter) {\n return formatter(this, options, fields);\n }\n if (options.get('tooltipChartTitle')) {\n header += '
    ' + options.get('tooltipChartTitle') + '
    \\n';\n }\n formats = this.options.get('tooltipFormat');\n if (!formats) {\n return '';\n }\n if (!$.isArray(formats)) {\n formats = [formats];\n }\n if (!$.isArray(fields)) {\n fields = [fields];\n }\n showFields = this.options.get('tooltipFormatFieldlist');\n showFieldsKey = this.options.get('tooltipFormatFieldlistKey');\n if (showFields && showFieldsKey) {\n // user-selected ordering of fields\n newFields = [];\n for (i = fields.length; i--;) {\n fv = fields[i][showFieldsKey];\n if ((j = $.inArray(fv, showFields)) != -1) {\n newFields[j] = fields[i];\n }\n }\n fields = newFields;\n }\n formatlen = formats.length;\n fieldlen = fields.length;\n for (i = 0; i < formatlen; i++) {\n format = formats[i];\n if (typeof format === 'string') {\n format = new SPFormat(format);\n }\n fclass = format.fclass || 'jqsfield';\n for (j = 0; j < fieldlen; j++) {\n if (!fields[j].isNull || !options.get('tooltipSkipNull')) {\n $.extend(fields[j], {\n prefix: options.get('tooltipPrefix'),\n suffix: options.get('tooltipSuffix')\n });\n text = format.render(fields[j], options.get('tooltipValueLookups'), options);\n entries.push('
    ' + text + '
    ');\n }\n }\n }\n if (entries.length) {\n return header + entries.join('\\n');\n }\n return '';\n },\n\n getCurrentRegionFields: function () {},\n\n calcHighlightColor: function (color, options) {\n var highlightColor = options.get('highlightColor'),\n lighten = options.get('highlightLighten'),\n parse, mult, rgbnew, i;\n if (highlightColor) {\n return highlightColor;\n }\n if (lighten) {\n // extract RGB values\n parse = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(color) || /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(color);\n if (parse) {\n rgbnew = [];\n mult = color.length === 4 ? 16 : 1;\n for (i = 0; i < 3; i++) {\n rgbnew[i] = clipval(Math.round(parseInt(parse[i + 1], 16) * mult * lighten), 0, 255);\n }\n return 'rgb(' + rgbnew.join(',') + ')';\n }\n\n }\n return color;\n }\n\n });\n\n barHighlightMixin = {\n changeHighlight: function (highlight) {\n var currentRegion = this.currentRegion,\n target = this.target,\n shapeids = this.regionShapes[currentRegion],\n newShapes;\n // will be null if the region value was null\n if (shapeids) {\n newShapes = this.renderRegion(currentRegion, highlight);\n if ($.isArray(newShapes) || $.isArray(shapeids)) {\n target.replaceWithShapes(shapeids, newShapes);\n this.regionShapes[currentRegion] = $.map(newShapes, function (newShape) {\n return newShape.id;\n });\n } else {\n target.replaceWithShape(shapeids, newShapes);\n this.regionShapes[currentRegion] = newShapes.id;\n }\n }\n },\n\n render: function () {\n var values = this.values,\n target = this.target,\n regionShapes = this.regionShapes,\n shapes, ids, i, j;\n\n if (!this.cls._super.render.call(this)) {\n return;\n }\n for (i = values.length; i--;) {\n shapes = this.renderRegion(i);\n if (shapes) {\n if ($.isArray(shapes)) {\n ids = [];\n for (j = shapes.length; j--;) {\n shapes[j].append();\n ids.push(shapes[j].id);\n }\n regionShapes[i] = ids;\n } else {\n shapes.append();\n regionShapes[i] = shapes.id; // store just the shapeid\n }\n } else {\n // null value\n regionShapes[i] = null;\n }\n }\n target.render();\n }\n };\n\n /**\n * Line charts\n */\n $.fn.sparkline.line = line = createClass($.fn.sparkline._base, {\n type: 'line',\n\n init: function (el, values, options, width, height) {\n line._super.init.call(this, el, values, options, width, height);\n this.vertices = [];\n this.regionMap = [];\n this.xvalues = [];\n this.yvalues = [];\n this.yminmax = [];\n this.hightlightSpotId = null;\n this.lastShapeId = null;\n this.initTarget();\n },\n\n getRegion: function (el, x, y) {\n var i,\n regionMap = this.regionMap; // maps regions to value positions\n for (i = regionMap.length; i--;) {\n if (regionMap[i] !== null && x >= regionMap[i][0] && x <= regionMap[i][1]) {\n return regionMap[i][2];\n }\n }\n return undefined;\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n isNull: this.yvalues[currentRegion] === null,\n x: this.xvalues[currentRegion],\n y: this.yvalues[currentRegion],\n color: this.options.get('lineColor'),\n fillColor: this.options.get('fillColor'),\n offset: currentRegion\n };\n },\n\n renderHighlight: function () {\n var currentRegion = this.currentRegion,\n target = this.target,\n vertex = this.vertices[currentRegion],\n options = this.options,\n spotRadius = options.get('spotRadius'),\n highlightSpotColor = options.get('highlightSpotColor'),\n highlightLineColor = options.get('highlightLineColor'),\n highlightSpot, highlightLine;\n\n if (!vertex) {\n return;\n }\n if (spotRadius && highlightSpotColor) {\n highlightSpot = target.drawCircle(vertex[0], vertex[1],\n spotRadius, undefined, highlightSpotColor);\n this.highlightSpotId = highlightSpot.id;\n target.insertAfterShape(this.lastShapeId, highlightSpot);\n }\n if (highlightLineColor) {\n highlightLine = target.drawLine(vertex[0], this.canvasTop, vertex[0],\n this.canvasTop + this.canvasHeight, highlightLineColor);\n this.highlightLineId = highlightLine.id;\n target.insertAfterShape(this.lastShapeId, highlightLine);\n }\n },\n\n removeHighlight: function () {\n var target = this.target;\n if (this.highlightSpotId) {\n target.removeShapeId(this.highlightSpotId);\n this.highlightSpotId = null;\n }\n if (this.highlightLineId) {\n target.removeShapeId(this.highlightLineId);\n this.highlightLineId = null;\n }\n },\n\n scanValues: function () {\n var values = this.values,\n valcount = values.length,\n xvalues = this.xvalues,\n yvalues = this.yvalues,\n yminmax = this.yminmax,\n i, val, isStr, isArray, sp;\n for (i = 0; i < valcount; i++) {\n val = values[i];\n isStr = typeof(values[i]) === 'string';\n isArray = typeof(values[i]) === 'object' && values[i] instanceof Array;\n sp = isStr && values[i].split(':');\n if (isStr && sp.length === 2) { // x:y\n xvalues.push(Number(sp[0]));\n yvalues.push(Number(sp[1]));\n yminmax.push(Number(sp[1]));\n } else if (isArray) {\n xvalues.push(val[0]);\n yvalues.push(val[1]);\n yminmax.push(val[1]);\n } else {\n xvalues.push(i);\n if (values[i] === null || values[i] === 'null') {\n yvalues.push(null);\n } else {\n yvalues.push(Number(val));\n yminmax.push(Number(val));\n }\n }\n }\n if (this.options.get('xvalues')) {\n xvalues = this.options.get('xvalues');\n }\n\n this.maxy = this.maxyorg = Math.max.apply(Math, yminmax);\n this.miny = this.minyorg = Math.min.apply(Math, yminmax);\n\n this.maxx = Math.max.apply(Math, xvalues);\n this.minx = Math.min.apply(Math, xvalues);\n\n this.xvalues = xvalues;\n this.yvalues = yvalues;\n this.yminmax = yminmax;\n\n },\n\n processRangeOptions: function () {\n var options = this.options,\n normalRangeMin = options.get('normalRangeMin'),\n normalRangeMax = options.get('normalRangeMax');\n\n if (normalRangeMin !== undefined) {\n if (normalRangeMin < this.miny) {\n this.miny = normalRangeMin;\n }\n if (normalRangeMax > this.maxy) {\n this.maxy = normalRangeMax;\n }\n }\n if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < this.miny)) {\n this.miny = options.get('chartRangeMin');\n }\n if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > this.maxy)) {\n this.maxy = options.get('chartRangeMax');\n }\n if (options.get('chartRangeMinX') !== undefined && (options.get('chartRangeClipX') || options.get('chartRangeMinX') < this.minx)) {\n this.minx = options.get('chartRangeMinX');\n }\n if (options.get('chartRangeMaxX') !== undefined && (options.get('chartRangeClipX') || options.get('chartRangeMaxX') > this.maxx)) {\n this.maxx = options.get('chartRangeMaxX');\n }\n\n },\n\n drawNormalRange: function (canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey) {\n var normalRangeMin = this.options.get('normalRangeMin'),\n normalRangeMax = this.options.get('normalRangeMax'),\n ytop = canvasTop + Math.round(canvasHeight - (canvasHeight * ((normalRangeMax - this.miny) / rangey))),\n height = Math.round((canvasHeight * (normalRangeMax - normalRangeMin)) / rangey);\n this.target.drawRect(canvasLeft, ytop, canvasWidth, height, undefined, this.options.get('normalRangeColor')).append();\n },\n\n render: function () {\n var options = this.options,\n target = this.target,\n canvasWidth = this.canvasWidth,\n canvasHeight = this.canvasHeight,\n vertices = this.vertices,\n spotRadius = options.get('spotRadius'),\n regionMap = this.regionMap,\n rangex, rangey, yvallast,\n canvasTop, canvasLeft,\n vertex, path, paths, x, y, xnext, xpos, xposnext,\n last, next, yvalcount, lineShapes, fillShapes, plen,\n valueSpots, hlSpotsEnabled, color, xvalues, yvalues, i;\n\n if (!line._super.render.call(this)) {\n return;\n }\n\n this.scanValues();\n this.processRangeOptions();\n\n xvalues = this.xvalues;\n yvalues = this.yvalues;\n\n if (!this.yminmax.length || this.yvalues.length < 2) {\n // empty or all null valuess\n return;\n }\n\n canvasTop = canvasLeft = 0;\n\n rangex = this.maxx - this.minx === 0 ? 1 : this.maxx - this.minx;\n rangey = this.maxy - this.miny === 0 ? 1 : this.maxy - this.miny;\n yvallast = this.yvalues.length - 1;\n\n if (spotRadius && (canvasWidth < (spotRadius * 4) || canvasHeight < (spotRadius * 4))) {\n spotRadius = 0;\n }\n if (spotRadius) {\n // adjust the canvas size as required so that spots will fit\n hlSpotsEnabled = options.get('highlightSpotColor') && !options.get('disableInteraction');\n if (hlSpotsEnabled || options.get('minSpotColor') || (options.get('spotColor') && yvalues[yvallast] === this.miny)) {\n canvasHeight -= Math.ceil(spotRadius);\n }\n if (hlSpotsEnabled || options.get('maxSpotColor') || (options.get('spotColor') && yvalues[yvallast] === this.maxy)) {\n canvasHeight -= Math.ceil(spotRadius);\n canvasTop += Math.ceil(spotRadius);\n }\n if (hlSpotsEnabled ||\n ((options.get('minSpotColor') || options.get('maxSpotColor')) && (yvalues[0] === this.miny || yvalues[0] === this.maxy))) {\n canvasLeft += Math.ceil(spotRadius);\n canvasWidth -= Math.ceil(spotRadius);\n }\n if (hlSpotsEnabled || options.get('spotColor') ||\n (options.get('minSpotColor') || options.get('maxSpotColor') &&\n (yvalues[yvallast] === this.miny || yvalues[yvallast] === this.maxy))) {\n canvasWidth -= Math.ceil(spotRadius);\n }\n }\n\n\n canvasHeight--;\n\n if (options.get('normalRangeMin') !== undefined && !options.get('drawNormalOnTop')) {\n this.drawNormalRange(canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey);\n }\n\n path = [];\n paths = [path];\n last = next = null;\n yvalcount = yvalues.length;\n for (i = 0; i < yvalcount; i++) {\n x = xvalues[i];\n xnext = xvalues[i + 1];\n y = yvalues[i];\n xpos = canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex));\n xposnext = i < yvalcount - 1 ? canvasLeft + Math.round((xnext - this.minx) * (canvasWidth / rangex)) : canvasWidth;\n next = xpos + ((xposnext - xpos) / 2);\n regionMap[i] = [last || 0, next, i];\n last = next;\n if (y === null) {\n if (i) {\n if (yvalues[i - 1] !== null) {\n path = [];\n paths.push(path);\n }\n vertices.push(null);\n }\n } else {\n if (y < this.miny) {\n y = this.miny;\n }\n if (y > this.maxy) {\n y = this.maxy;\n }\n if (!path.length) {\n // previous value was null\n path.push([xpos, canvasTop + canvasHeight]);\n }\n vertex = [xpos, canvasTop + Math.round(canvasHeight - (canvasHeight * ((y - this.miny) / rangey)))];\n path.push(vertex);\n vertices.push(vertex);\n }\n }\n\n lineShapes = [];\n fillShapes = [];\n plen = paths.length;\n for (i = 0; i < plen; i++) {\n path = paths[i];\n if (path.length) {\n if (options.get('fillColor')) {\n path.push([path[path.length - 1][0], (canvasTop + canvasHeight)]);\n fillShapes.push(path.slice(0));\n path.pop();\n }\n // if there's only a single point in this path, then we want to display it\n // as a vertical line which means we keep path[0] as is\n if (path.length > 2) {\n // else we want the first value\n path[0] = [path[0][0], path[1][1]];\n }\n lineShapes.push(path);\n }\n }\n\n // draw the fill first, then optionally the normal range, then the line on top of that\n plen = fillShapes.length;\n for (i = 0; i < plen; i++) {\n target.drawShape(fillShapes[i],\n options.get('fillColor'), options.get('fillColor')).append();\n }\n\n if (options.get('normalRangeMin') !== undefined && options.get('drawNormalOnTop')) {\n this.drawNormalRange(canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey);\n }\n\n plen = lineShapes.length;\n for (i = 0; i < plen; i++) {\n target.drawShape(lineShapes[i], options.get('lineColor'), undefined,\n options.get('lineWidth')).append();\n }\n\n if (spotRadius && options.get('valueSpots')) {\n valueSpots = options.get('valueSpots');\n if (valueSpots.get === undefined) {\n valueSpots = new RangeMap(valueSpots);\n }\n for (i = 0; i < yvalcount; i++) {\n color = valueSpots.get(yvalues[i]);\n if (color) {\n target.drawCircle(canvasLeft + Math.round((xvalues[i] - this.minx) * (canvasWidth / rangex)),\n canvasTop + Math.round(canvasHeight - (canvasHeight * ((yvalues[i] - this.miny) / rangey))),\n spotRadius, undefined,\n color).append();\n }\n }\n\n }\n if (spotRadius && options.get('spotColor') && yvalues[yvallast] !== null) {\n target.drawCircle(canvasLeft + Math.round((xvalues[xvalues.length - 1] - this.minx) * (canvasWidth / rangex)),\n canvasTop + Math.round(canvasHeight - (canvasHeight * ((yvalues[yvallast] - this.miny) / rangey))),\n spotRadius, undefined,\n options.get('spotColor')).append();\n }\n if (this.maxy !== this.minyorg) {\n if (spotRadius && options.get('minSpotColor')) {\n x = xvalues[$.inArray(this.minyorg, yvalues)];\n target.drawCircle(canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex)),\n canvasTop + Math.round(canvasHeight - (canvasHeight * ((this.minyorg - this.miny) / rangey))),\n spotRadius, undefined,\n options.get('minSpotColor')).append();\n }\n if (spotRadius && options.get('maxSpotColor')) {\n x = xvalues[$.inArray(this.maxyorg, yvalues)];\n target.drawCircle(canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex)),\n canvasTop + Math.round(canvasHeight - (canvasHeight * ((this.maxyorg - this.miny) / rangey))),\n spotRadius, undefined,\n options.get('maxSpotColor')).append();\n }\n }\n\n this.lastShapeId = target.getLastShapeId();\n this.canvasTop = canvasTop;\n target.render();\n }\n });\n\n /**\n * Bar charts\n */\n $.fn.sparkline.bar = bar = createClass($.fn.sparkline._base, barHighlightMixin, {\n type: 'bar',\n\n init: function (el, values, options, width, height) {\n var barWidth = parseInt(options.get('barWidth'), 10),\n barSpacing = parseInt(options.get('barSpacing'), 10),\n chartRangeMin = options.get('chartRangeMin'),\n chartRangeMax = options.get('chartRangeMax'),\n chartRangeClip = options.get('chartRangeClip'),\n stackMin = Infinity,\n stackMax = -Infinity,\n isStackString, groupMin, groupMax, stackRanges,\n numValues, i, vlen, range, zeroAxis, xaxisOffset, min, max, clipMin, clipMax,\n stacked, vlist, j, slen, svals, val, yoffset, yMaxCalc, canvasHeightEf;\n bar._super.init.call(this, el, values, options, width, height);\n\n // scan values to determine whether to stack bars\n for (i = 0, vlen = values.length; i < vlen; i++) {\n val = values[i];\n isStackString = typeof(val) === 'string' && val.indexOf(':') > -1;\n if (isStackString || $.isArray(val)) {\n stacked = true;\n if (isStackString) {\n val = values[i] = normalizeValues(val.split(':'));\n }\n val = remove(val, null); // min/max will treat null as zero\n groupMin = Math.min.apply(Math, val);\n groupMax = Math.max.apply(Math, val);\n if (groupMin < stackMin) {\n stackMin = groupMin;\n }\n if (groupMax > stackMax) {\n stackMax = groupMax;\n }\n }\n }\n\n this.stacked = stacked;\n this.regionShapes = {};\n this.barWidth = barWidth;\n this.barSpacing = barSpacing;\n this.totalBarWidth = barWidth + barSpacing;\n this.width = width = (values.length * barWidth) + ((values.length - 1) * barSpacing);\n\n this.initTarget();\n\n if (chartRangeClip) {\n clipMin = chartRangeMin === undefined ? -Infinity : chartRangeMin;\n clipMax = chartRangeMax === undefined ? Infinity : chartRangeMax;\n }\n\n numValues = [];\n stackRanges = stacked ? [] : numValues;\n var stackTotals = [];\n var stackRangesNeg = [];\n for (i = 0, vlen = values.length; i < vlen; i++) {\n if (stacked) {\n vlist = values[i];\n values[i] = svals = [];\n stackTotals[i] = 0;\n stackRanges[i] = stackRangesNeg[i] = 0;\n for (j = 0, slen = vlist.length; j < slen; j++) {\n val = svals[j] = chartRangeClip ? clipval(vlist[j], clipMin, clipMax) : vlist[j];\n if (val !== null) {\n if (val > 0) {\n stackTotals[i] += val;\n }\n if (stackMin < 0 && stackMax > 0) {\n if (val < 0) {\n stackRangesNeg[i] += Math.abs(val);\n } else {\n stackRanges[i] += val;\n }\n } else {\n stackRanges[i] += Math.abs(val - (val < 0 ? stackMax : stackMin));\n }\n numValues.push(val);\n }\n }\n } else {\n val = chartRangeClip ? clipval(values[i], clipMin, clipMax) : values[i];\n val = values[i] = normalizeValue(val);\n if (val !== null) {\n numValues.push(val);\n }\n }\n }\n this.max = max = Math.max.apply(Math, numValues);\n this.min = min = Math.min.apply(Math, numValues);\n this.stackMax = stackMax = stacked ? Math.max.apply(Math, stackTotals) : max;\n this.stackMin = stackMin = stacked ? Math.min.apply(Math, numValues) : min;\n\n if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < min)) {\n min = options.get('chartRangeMin');\n }\n if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > max)) {\n max = options.get('chartRangeMax');\n }\n\n this.zeroAxis = zeroAxis = options.get('zeroAxis', true);\n if (min <= 0 && max >= 0 && zeroAxis) {\n xaxisOffset = 0;\n } else if (zeroAxis == false) {\n xaxisOffset = min;\n } else if (min > 0) {\n xaxisOffset = min;\n } else {\n xaxisOffset = max;\n }\n this.xaxisOffset = xaxisOffset;\n\n range = stacked ? (Math.max.apply(Math, stackRanges) + Math.max.apply(Math, stackRangesNeg)) : max - min;\n\n // as we plot zero/min values a single pixel line, we add a pixel to all other\n // values - Reduce the effective canvas size to suit\n this.canvasHeightEf = (zeroAxis && min < 0) ? this.canvasHeight - 2 : this.canvasHeight - 1;\n\n if (min < xaxisOffset) {\n yMaxCalc = (stacked && max >= 0) ? stackMax : max;\n yoffset = (yMaxCalc - xaxisOffset) / range * this.canvasHeight;\n if (yoffset !== Math.ceil(yoffset)) {\n this.canvasHeightEf -= 2;\n yoffset = Math.ceil(yoffset);\n }\n } else {\n yoffset = this.canvasHeight;\n }\n this.yoffset = yoffset;\n\n if ($.isArray(options.get('colorMap'))) {\n this.colorMapByIndex = options.get('colorMap');\n this.colorMapByValue = null;\n } else {\n this.colorMapByIndex = null;\n this.colorMapByValue = options.get('colorMap');\n if (this.colorMapByValue && this.colorMapByValue.get === undefined) {\n this.colorMapByValue = new RangeMap(this.colorMapByValue);\n }\n }\n\n this.range = range;\n },\n\n getRegion: function (el, x, y) {\n var result = Math.floor(x / this.totalBarWidth);\n return (result < 0 || result >= this.values.length) ? undefined : result;\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion,\n values = ensureArray(this.values[currentRegion]),\n result = [],\n value, i;\n for (i = values.length; i--;) {\n value = values[i];\n result.push({\n isNull: value === null,\n value: value,\n color: this.calcColor(i, value, currentRegion),\n offset: currentRegion\n });\n }\n return result;\n },\n\n calcColor: function (stacknum, value, valuenum) {\n var colorMapByIndex = this.colorMapByIndex,\n colorMapByValue = this.colorMapByValue,\n options = this.options,\n color, newColor;\n if (this.stacked) {\n color = options.get('stackedBarColor');\n } else {\n color = (value < 0) ? options.get('negBarColor') : options.get('barColor');\n }\n if (value === 0 && options.get('zeroColor') !== undefined) {\n color = options.get('zeroColor');\n }\n if (colorMapByValue && (newColor = colorMapByValue.get(value))) {\n color = newColor;\n } else if (colorMapByIndex && colorMapByIndex.length > valuenum) {\n color = colorMapByIndex[valuenum];\n }\n return $.isArray(color) ? color[stacknum % color.length] : color;\n },\n\n /**\n * Render bar(s) for a region\n */\n renderRegion: function (valuenum, highlight) {\n var vals = this.values[valuenum],\n options = this.options,\n xaxisOffset = this.xaxisOffset,\n result = [],\n range = this.range,\n stacked = this.stacked,\n target = this.target,\n x = valuenum * this.totalBarWidth,\n canvasHeightEf = this.canvasHeightEf,\n yoffset = this.yoffset,\n y, height, color, isNull, yoffsetNeg, i, valcount, val, minPlotted, allMin;\n\n vals = $.isArray(vals) ? vals : [vals];\n valcount = vals.length;\n val = vals[0];\n isNull = all(null, vals);\n allMin = all(xaxisOffset, vals, true);\n\n if (isNull) {\n if (options.get('nullColor')) {\n color = highlight ? options.get('nullColor') : this.calcHighlightColor(options.get('nullColor'), options);\n y = (yoffset > 0) ? yoffset - 1 : yoffset;\n return target.drawRect(x, y, this.barWidth - 1, 0, color, color);\n } else {\n return undefined;\n }\n }\n yoffsetNeg = yoffset;\n for (i = 0; i < valcount; i++) {\n val = vals[i];\n\n if (stacked && val === xaxisOffset) {\n if (!allMin || minPlotted) {\n continue;\n }\n minPlotted = true;\n }\n\n if (range > 0) {\n height = Math.floor(canvasHeightEf * ((Math.abs(val - xaxisOffset) / range))) + 1;\n } else {\n height = 1;\n }\n if (val < xaxisOffset || (val === xaxisOffset && yoffset === 0)) {\n y = yoffsetNeg;\n yoffsetNeg += height;\n } else {\n y = yoffset - height;\n yoffset -= height;\n }\n color = this.calcColor(i, val, valuenum);\n if (highlight) {\n color = this.calcHighlightColor(color, options);\n }\n result.push(target.drawRect(x, y, this.barWidth - 1, height - 1, color, color));\n }\n if (result.length === 1) {\n return result[0];\n }\n return result;\n }\n });\n\n /**\n * Tristate charts\n */\n $.fn.sparkline.tristate = tristate = createClass($.fn.sparkline._base, barHighlightMixin, {\n type: 'tristate',\n\n init: function (el, values, options, width, height) {\n var barWidth = parseInt(options.get('barWidth'), 10),\n barSpacing = parseInt(options.get('barSpacing'), 10);\n tristate._super.init.call(this, el, values, options, width, height);\n\n this.regionShapes = {};\n this.barWidth = barWidth;\n this.barSpacing = barSpacing;\n this.totalBarWidth = barWidth + barSpacing;\n this.values = $.map(values, Number);\n this.width = width = (values.length * barWidth) + ((values.length - 1) * barSpacing);\n\n if ($.isArray(options.get('colorMap'))) {\n this.colorMapByIndex = options.get('colorMap');\n this.colorMapByValue = null;\n } else {\n this.colorMapByIndex = null;\n this.colorMapByValue = options.get('colorMap');\n if (this.colorMapByValue && this.colorMapByValue.get === undefined) {\n this.colorMapByValue = new RangeMap(this.colorMapByValue);\n }\n }\n this.initTarget();\n },\n\n getRegion: function (el, x, y) {\n return Math.floor(x / this.totalBarWidth);\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n isNull: this.values[currentRegion] === undefined,\n value: this.values[currentRegion],\n color: this.calcColor(this.values[currentRegion], currentRegion),\n offset: currentRegion\n };\n },\n\n calcColor: function (value, valuenum) {\n var values = this.values,\n options = this.options,\n colorMapByIndex = this.colorMapByIndex,\n colorMapByValue = this.colorMapByValue,\n color, newColor;\n\n if (colorMapByValue && (newColor = colorMapByValue.get(value))) {\n color = newColor;\n } else if (colorMapByIndex && colorMapByIndex.length > valuenum) {\n color = colorMapByIndex[valuenum];\n } else if (values[valuenum] < 0) {\n color = options.get('negBarColor');\n } else if (values[valuenum] > 0) {\n color = options.get('posBarColor');\n } else {\n color = options.get('zeroBarColor');\n }\n return color;\n },\n\n renderRegion: function (valuenum, highlight) {\n var values = this.values,\n options = this.options,\n target = this.target,\n canvasHeight, height, halfHeight,\n x, y, color;\n\n canvasHeight = target.pixelHeight;\n halfHeight = Math.round(canvasHeight / 2);\n\n x = valuenum * this.totalBarWidth;\n if (values[valuenum] < 0) {\n y = halfHeight;\n height = halfHeight - 1;\n } else if (values[valuenum] > 0) {\n y = 0;\n height = halfHeight - 1;\n } else {\n y = halfHeight - 1;\n height = 2;\n }\n color = this.calcColor(values[valuenum], valuenum);\n if (color === null) {\n return;\n }\n if (highlight) {\n color = this.calcHighlightColor(color, options);\n }\n return target.drawRect(x, y, this.barWidth - 1, height - 1, color, color);\n }\n });\n\n /**\n * Discrete charts\n */\n $.fn.sparkline.discrete = discrete = createClass($.fn.sparkline._base, barHighlightMixin, {\n type: 'discrete',\n\n init: function (el, values, options, width, height) {\n discrete._super.init.call(this, el, values, options, width, height);\n\n this.regionShapes = {};\n this.values = values = $.map(values, Number);\n this.min = Math.min.apply(Math, values);\n this.max = Math.max.apply(Math, values);\n this.range = this.max - this.min;\n this.width = width = options.get('width') === 'auto' ? values.length * 2 : this.width;\n this.interval = Math.floor(width / values.length);\n this.itemWidth = width / values.length;\n if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < this.min)) {\n this.min = options.get('chartRangeMin');\n }\n if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > this.max)) {\n this.max = options.get('chartRangeMax');\n }\n this.initTarget();\n if (this.target) {\n this.lineHeight = options.get('lineHeight') === 'auto' ? Math.round(this.canvasHeight * 0.3) : options.get('lineHeight');\n }\n },\n\n getRegion: function (el, x, y) {\n return Math.floor(x / this.itemWidth);\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n isNull: this.values[currentRegion] === undefined,\n value: this.values[currentRegion],\n offset: currentRegion\n };\n },\n\n renderRegion: function (valuenum, highlight) {\n var values = this.values,\n options = this.options,\n min = this.min,\n max = this.max,\n range = this.range,\n interval = this.interval,\n target = this.target,\n canvasHeight = this.canvasHeight,\n lineHeight = this.lineHeight,\n pheight = canvasHeight - lineHeight,\n ytop, val, color, x;\n\n val = clipval(values[valuenum], min, max);\n x = valuenum * interval;\n ytop = Math.round(pheight - pheight * ((val - min) / range));\n color = (options.get('thresholdColor') && val < options.get('thresholdValue')) ? options.get('thresholdColor') : options.get('lineColor');\n if (highlight) {\n color = this.calcHighlightColor(color, options);\n }\n return target.drawLine(x, ytop, x, ytop + lineHeight, color);\n }\n });\n\n /**\n * Bullet charts\n */\n $.fn.sparkline.bullet = bullet = createClass($.fn.sparkline._base, {\n type: 'bullet',\n\n init: function (el, values, options, width, height) {\n var min, max, vals;\n bullet._super.init.call(this, el, values, options, width, height);\n\n // values: target, performance, range1, range2, range3\n this.values = values = normalizeValues(values);\n // target or performance could be null\n vals = values.slice();\n vals[0] = vals[0] === null ? vals[2] : vals[0];\n vals[1] = values[1] === null ? vals[2] : vals[1];\n min = Math.min.apply(Math, values);\n max = Math.max.apply(Math, values);\n if (options.get('base') === undefined) {\n min = min < 0 ? min : 0;\n } else {\n min = options.get('base');\n }\n this.min = min;\n this.max = max;\n this.range = max - min;\n this.shapes = {};\n this.valueShapes = {};\n this.regiondata = {};\n this.width = width = options.get('width') === 'auto' ? '4.0em' : width;\n this.target = this.$el.simpledraw(width, height, options.get('composite'));\n if (!values.length) {\n this.disabled = true;\n }\n this.initTarget();\n },\n\n getRegion: function (el, x, y) {\n var shapeid = this.target.getShapeAt(el, x, y);\n return (shapeid !== undefined && this.shapes[shapeid] !== undefined) ? this.shapes[shapeid] : undefined;\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n fieldkey: currentRegion.substr(0, 1),\n value: this.values[currentRegion.substr(1)],\n region: currentRegion\n };\n },\n\n changeHighlight: function (highlight) {\n var currentRegion = this.currentRegion,\n shapeid = this.valueShapes[currentRegion],\n shape;\n delete this.shapes[shapeid];\n switch (currentRegion.substr(0, 1)) {\n case 'r':\n shape = this.renderRange(currentRegion.substr(1), highlight);\n break;\n case 'p':\n shape = this.renderPerformance(highlight);\n break;\n case 't':\n shape = this.renderTarget(highlight);\n break;\n }\n this.valueShapes[currentRegion] = shape.id;\n this.shapes[shape.id] = currentRegion;\n this.target.replaceWithShape(shapeid, shape);\n },\n\n renderRange: function (rn, highlight) {\n var rangeval = this.values[rn],\n rangewidth = Math.round(this.canvasWidth * ((rangeval - this.min) / this.range)),\n color = this.options.get('rangeColors')[rn - 2];\n if (highlight) {\n color = this.calcHighlightColor(color, this.options);\n }\n return this.target.drawRect(0, 0, rangewidth - 1, this.canvasHeight - 1, color, color);\n },\n\n renderPerformance: function (highlight) {\n var perfval = this.values[1],\n perfwidth = Math.round(this.canvasWidth * ((perfval - this.min) / this.range)),\n color = this.options.get('performanceColor');\n if (highlight) {\n color = this.calcHighlightColor(color, this.options);\n }\n return this.target.drawRect(0, Math.round(this.canvasHeight * 0.3), perfwidth - 1,\n Math.round(this.canvasHeight * 0.4) - 1, color, color);\n },\n\n renderTarget: function (highlight) {\n var targetval = this.values[0],\n x = Math.round(this.canvasWidth * ((targetval - this.min) / this.range) - (this.options.get('targetWidth') / 2)),\n targettop = Math.round(this.canvasHeight * 0.10),\n targetheight = this.canvasHeight - (targettop * 2),\n color = this.options.get('targetColor');\n if (highlight) {\n color = this.calcHighlightColor(color, this.options);\n }\n return this.target.drawRect(x, targettop, this.options.get('targetWidth') - 1, targetheight - 1, color, color);\n },\n\n render: function () {\n var vlen = this.values.length,\n target = this.target,\n i, shape;\n if (!bullet._super.render.call(this)) {\n return;\n }\n for (i = 2; i < vlen; i++) {\n shape = this.renderRange(i).append();\n this.shapes[shape.id] = 'r' + i;\n this.valueShapes['r' + i] = shape.id;\n }\n if (this.values[1] !== null) {\n shape = this.renderPerformance().append();\n this.shapes[shape.id] = 'p1';\n this.valueShapes.p1 = shape.id;\n }\n if (this.values[0] !== null) {\n shape = this.renderTarget().append();\n this.shapes[shape.id] = 't0';\n this.valueShapes.t0 = shape.id;\n }\n target.render();\n }\n });\n\n /**\n * Pie charts\n */\n $.fn.sparkline.pie = pie = createClass($.fn.sparkline._base, {\n type: 'pie',\n\n init: function (el, values, options, width, height) {\n var total = 0, i;\n\n pie._super.init.call(this, el, values, options, width, height);\n\n this.shapes = {}; // map shape ids to value offsets\n this.valueShapes = {}; // maps value offsets to shape ids\n this.values = values = $.map(values, Number);\n\n if (options.get('width') === 'auto') {\n this.width = this.height;\n }\n\n if (values.length > 0) {\n for (i = values.length; i--;) {\n total += values[i];\n }\n }\n this.total = total;\n this.initTarget();\n this.radius = Math.floor(Math.min(this.canvasWidth, this.canvasHeight) / 2);\n },\n\n getRegion: function (el, x, y) {\n var shapeid = this.target.getShapeAt(el, x, y);\n return (shapeid !== undefined && this.shapes[shapeid] !== undefined) ? this.shapes[shapeid] : undefined;\n },\n\n getCurrentRegionFields: function () {\n var currentRegion = this.currentRegion;\n return {\n isNull: this.values[currentRegion] === undefined,\n value: this.values[currentRegion],\n percent: this.values[currentRegion] / this.total * 100,\n color: this.options.get('sliceColors')[currentRegion % this.options.get('sliceColors').length],\n offset: currentRegion\n };\n },\n\n changeHighlight: function (highlight) {\n var currentRegion = this.currentRegion,\n newslice = this.renderSlice(currentRegion, highlight),\n shapeid = this.valueShapes[currentRegion];\n delete this.shapes[shapeid];\n this.target.replaceWithShape(shapeid, newslice);\n this.valueShapes[currentRegion] = newslice.id;\n this.shapes[newslice.id] = currentRegion;\n },\n\n renderSlice: function (valuenum, highlight) {\n var target = this.target,\n options = this.options,\n radius = this.radius,\n borderWidth = options.get('borderWidth'),\n offset = options.get('offset'),\n circle = 2 * Math.PI,\n values = this.values,\n total = this.total,\n next = offset ? (2*Math.PI)*(offset/360) : 0,\n start, end, i, vlen, color;\n\n vlen = values.length;\n for (i = 0; i < vlen; i++) {\n start = next;\n end = next;\n if (total > 0) { // avoid divide by zero\n end = next + (circle * (values[i] / total));\n }\n if (valuenum === i) {\n color = options.get('sliceColors')[i % options.get('sliceColors').length];\n if (highlight) {\n color = this.calcHighlightColor(color, options);\n }\n\n return target.drawPieSlice(radius, radius, radius - borderWidth, start, end, undefined, color);\n }\n next = end;\n }\n },\n\n render: function () {\n var target = this.target,\n values = this.values,\n options = this.options,\n radius = this.radius,\n borderWidth = options.get('borderWidth'),\n donutWidth = options.get('donutWidth'),\n shape, i;\n\n if (!pie._super.render.call(this)) {\n return;\n }\n if (borderWidth) {\n target.drawCircle(radius, radius, Math.floor(radius - (borderWidth / 2)),\n options.get('borderColor'), undefined, borderWidth).append();\n }\n for (i = values.length; i--;) {\n if (values[i]) { // don't render zero values\n shape = this.renderSlice(i).append();\n this.valueShapes[i] = shape.id; // store just the shapeid\n this.shapes[shape.id] = i;\n }\n }\n if (donutWidth) {\n target.drawCircle(radius, radius, radius - donutWidth, options.get('donutColor'), \n options.get('donutColor'), 0).append();\n }\n target.render();\n }\n });\n\n /**\n * Box plots\n */\n $.fn.sparkline.box = box = createClass($.fn.sparkline._base, {\n type: 'box',\n\n init: function (el, values, options, width, height) {\n box._super.init.call(this, el, values, options, width, height);\n this.values = $.map(values, Number);\n this.width = options.get('width') === 'auto' ? '4.0em' : width;\n this.initTarget();\n if (!this.values.length) {\n this.disabled = 1;\n }\n },\n\n /**\n * Simulate a single region\n */\n getRegion: function () {\n return 1;\n },\n\n getCurrentRegionFields: function () {\n var result = [\n { field: 'lq', value: this.quartiles[0] },\n { field: 'med', value: this.quartiles[1] },\n { field: 'uq', value: this.quartiles[2] }\n ];\n if (this.loutlier !== undefined) {\n result.push({ field: 'lo', value: this.loutlier});\n }\n if (this.routlier !== undefined) {\n result.push({ field: 'ro', value: this.routlier});\n }\n if (this.lwhisker !== undefined) {\n result.push({ field: 'lw', value: this.lwhisker});\n }\n if (this.rwhisker !== undefined) {\n result.push({ field: 'rw', value: this.rwhisker});\n }\n return result;\n },\n\n render: function () {\n var target = this.target,\n values = this.values,\n vlen = values.length,\n options = this.options,\n canvasWidth = this.canvasWidth,\n canvasHeight = this.canvasHeight,\n minValue = options.get('chartRangeMin') === undefined ? Math.min.apply(Math, values) : options.get('chartRangeMin'),\n maxValue = options.get('chartRangeMax') === undefined ? Math.max.apply(Math, values) : options.get('chartRangeMax'),\n canvasLeft = 0,\n lwhisker, loutlier, iqr, q1, q2, q3, rwhisker, routlier, i,\n size, unitSize;\n\n if (!box._super.render.call(this)) {\n return;\n }\n\n if (options.get('raw')) {\n if (options.get('showOutliers') && values.length > 5) {\n loutlier = values[0];\n lwhisker = values[1];\n q1 = values[2];\n q2 = values[3];\n q3 = values[4];\n rwhisker = values[5];\n routlier = values[6];\n } else {\n lwhisker = values[0];\n q1 = values[1];\n q2 = values[2];\n q3 = values[3];\n rwhisker = values[4];\n }\n } else {\n values.sort(function (a, b) { return a - b; });\n q1 = quartile(values, 1);\n q2 = quartile(values, 2);\n q3 = quartile(values, 3);\n iqr = q3 - q1;\n if (options.get('showOutliers')) {\n lwhisker = rwhisker = undefined;\n for (i = 0; i < vlen; i++) {\n if (lwhisker === undefined && values[i] > q1 - (iqr * options.get('outlierIQR'))) {\n lwhisker = values[i];\n }\n if (values[i] < q3 + (iqr * options.get('outlierIQR'))) {\n rwhisker = values[i];\n }\n }\n loutlier = values[0];\n routlier = values[vlen - 1];\n } else {\n lwhisker = values[0];\n rwhisker = values[vlen - 1];\n }\n }\n this.quartiles = [q1, q2, q3];\n this.lwhisker = lwhisker;\n this.rwhisker = rwhisker;\n this.loutlier = loutlier;\n this.routlier = routlier;\n\n unitSize = canvasWidth / (maxValue - minValue + 1);\n if (options.get('showOutliers')) {\n canvasLeft = Math.ceil(options.get('spotRadius'));\n canvasWidth -= 2 * Math.ceil(options.get('spotRadius'));\n unitSize = canvasWidth / (maxValue - minValue + 1);\n if (loutlier < lwhisker) {\n target.drawCircle((loutlier - minValue) * unitSize + canvasLeft,\n canvasHeight / 2,\n options.get('spotRadius'),\n options.get('outlierLineColor'),\n options.get('outlierFillColor')).append();\n }\n if (routlier > rwhisker) {\n target.drawCircle((routlier - minValue) * unitSize + canvasLeft,\n canvasHeight / 2,\n options.get('spotRadius'),\n options.get('outlierLineColor'),\n options.get('outlierFillColor')).append();\n }\n }\n\n // box\n target.drawRect(\n Math.round((q1 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight * 0.1),\n Math.round((q3 - q1) * unitSize),\n Math.round(canvasHeight * 0.8),\n options.get('boxLineColor'),\n options.get('boxFillColor')).append();\n // left whisker\n target.drawLine(\n Math.round((lwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 2),\n Math.round((q1 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 2),\n options.get('lineColor')).append();\n target.drawLine(\n Math.round((lwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 4),\n Math.round((lwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight - canvasHeight / 4),\n options.get('whiskerColor')).append();\n // right whisker\n target.drawLine(Math.round((rwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 2),\n Math.round((q3 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 2),\n options.get('lineColor')).append();\n target.drawLine(\n Math.round((rwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight / 4),\n Math.round((rwhisker - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight - canvasHeight / 4),\n options.get('whiskerColor')).append();\n // median line\n target.drawLine(\n Math.round((q2 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight * 0.1),\n Math.round((q2 - minValue) * unitSize + canvasLeft),\n Math.round(canvasHeight * 0.9),\n options.get('medianColor')).append();\n if (options.get('target')) {\n size = Math.ceil(options.get('spotRadius'));\n target.drawLine(\n Math.round((options.get('target') - minValue) * unitSize + canvasLeft),\n Math.round((canvasHeight / 2) - size),\n Math.round((options.get('target') - minValue) * unitSize + canvasLeft),\n Math.round((canvasHeight / 2) + size),\n options.get('targetColor')).append();\n target.drawLine(\n Math.round((options.get('target') - minValue) * unitSize + canvasLeft - size),\n Math.round(canvasHeight / 2),\n Math.round((options.get('target') - minValue) * unitSize + canvasLeft + size),\n Math.round(canvasHeight / 2),\n options.get('targetColor')).append();\n }\n target.render();\n }\n });\n\n // Setup a very simple \"virtual canvas\" to make drawing the few shapes we need easier\n // This is accessible as $(foo).simpledraw()\n\n VShape = createClass({\n init: function (target, id, type, args) {\n this.target = target;\n this.id = id;\n this.type = type;\n this.args = args;\n },\n append: function () {\n this.target.appendShape(this);\n return this;\n }\n });\n\n VCanvas_base = createClass({\n _pxregex: /(\\d+)(px)?\\s*$/i,\n\n init: function (width, height, target) {\n if (!width) {\n return;\n }\n this.width = width;\n this.height = height;\n this.target = target;\n this.lastShapeId = null;\n if (target[0]) {\n target = target[0];\n }\n $.data(target, '_jqs_vcanvas', this);\n },\n\n drawLine: function (x1, y1, x2, y2, lineColor, lineWidth) {\n return this.drawShape([[x1, y1], [x2, y2]], lineColor, lineWidth);\n },\n\n drawShape: function (path, lineColor, fillColor, lineWidth) {\n return this._genShape('Shape', [path, lineColor, fillColor, lineWidth]);\n },\n\n drawCircle: function (x, y, radius, lineColor, fillColor, lineWidth) {\n return this._genShape('Circle', [x, y, radius, lineColor, fillColor, lineWidth]);\n },\n\n drawPieSlice: function (x, y, radius, startAngle, endAngle, lineColor, fillColor) {\n return this._genShape('PieSlice', [x, y, radius, startAngle, endAngle, lineColor, fillColor]);\n },\n\n drawRect: function (x, y, width, height, lineColor, fillColor) {\n return this._genShape('Rect', [x, y, width, height, lineColor, fillColor]);\n },\n\n getElement: function () {\n return this.canvas;\n },\n\n /**\n * Return the most recently inserted shape id\n */\n getLastShapeId: function () {\n return this.lastShapeId;\n },\n\n /**\n * Clear and reset the canvas\n */\n reset: function () {\n alert('reset not implemented');\n },\n\n _insert: function (el, target) {\n $(target).html(el);\n },\n\n /**\n * Calculate the pixel dimensions of the canvas\n */\n _calculatePixelDims: function (width, height, canvas) {\n // XXX This should probably be a configurable option\n var match;\n match = this._pxregex.exec(height);\n if (match) {\n this.pixelHeight = match[1];\n } else {\n this.pixelHeight = $(canvas).height();\n }\n match = this._pxregex.exec(width);\n if (match) {\n this.pixelWidth = match[1];\n } else {\n this.pixelWidth = $(canvas).width();\n }\n },\n\n /**\n * Generate a shape object and id for later rendering\n */\n _genShape: function (shapetype, shapeargs) {\n var id = shapeCount++;\n shapeargs.unshift(id);\n return new VShape(this, id, shapetype, shapeargs);\n },\n\n /**\n * Add a shape to the end of the render queue\n */\n appendShape: function (shape) {\n alert('appendShape not implemented');\n },\n\n /**\n * Replace one shape with another\n */\n replaceWithShape: function (shapeid, shape) {\n alert('replaceWithShape not implemented');\n },\n\n /**\n * Insert one shape after another in the render queue\n */\n insertAfterShape: function (shapeid, shape) {\n alert('insertAfterShape not implemented');\n },\n\n /**\n * Remove a shape from the queue\n */\n removeShapeId: function (shapeid) {\n alert('removeShapeId not implemented');\n },\n\n /**\n * Find a shape at the specified x/y co-ordinates\n */\n getShapeAt: function (el, x, y) {\n alert('getShapeAt not implemented');\n },\n\n /**\n * Render all queued shapes onto the canvas\n */\n render: function () {\n alert('render not implemented');\n }\n });\n\n VCanvas_canvas = createClass(VCanvas_base, {\n init: function (width, height, target, interact) {\n VCanvas_canvas._super.init.call(this, width, height, target);\n this.canvas = document.createElement('canvas');\n if (target[0]) {\n target = target[0];\n }\n $.data(target, '_jqs_vcanvas', this);\n $(this.canvas).css({ display: 'inline-block', width: width, height: height, verticalAlign: 'top' });\n this._insert(this.canvas, target);\n this._calculatePixelDims(width, height, this.canvas);\n this.canvas.width = this.pixelWidth;\n this.canvas.height = this.pixelHeight;\n this.interact = interact;\n this.shapes = {};\n this.shapeseq = [];\n this.currentTargetShapeId = undefined;\n $(this.canvas).css({width: this.pixelWidth, height: this.pixelHeight});\n },\n\n _getContext: function (lineColor, fillColor, lineWidth) {\n var context = this.canvas.getContext('2d');\n if (lineColor !== undefined) {\n context.strokeStyle = lineColor;\n }\n context.lineWidth = lineWidth === undefined ? 1 : lineWidth;\n if (fillColor !== undefined) {\n context.fillStyle = fillColor;\n }\n return context;\n },\n\n reset: function () {\n var context = this._getContext();\n context.clearRect(0, 0, this.pixelWidth, this.pixelHeight);\n this.shapes = {};\n this.shapeseq = [];\n this.currentTargetShapeId = undefined;\n },\n\n _drawShape: function (shapeid, path, lineColor, fillColor, lineWidth) {\n var context = this._getContext(lineColor, fillColor, lineWidth),\n i, plen;\n context.beginPath();\n context.moveTo(path[0][0] + 0.5, path[0][1] + 0.5);\n for (i = 1, plen = path.length; i < plen; i++) {\n context.lineTo(path[i][0] + 0.5, path[i][1] + 0.5); // the 0.5 offset gives us crisp pixel-width lines\n }\n if (lineColor !== undefined) {\n context.stroke();\n }\n if (fillColor !== undefined) {\n context.fill();\n }\n if (this.targetX !== undefined && this.targetY !== undefined &&\n context.isPointInPath(this.targetX, this.targetY)) {\n this.currentTargetShapeId = shapeid;\n }\n },\n\n _drawCircle: function (shapeid, x, y, radius, lineColor, fillColor, lineWidth) {\n var context = this._getContext(lineColor, fillColor, lineWidth);\n context.beginPath();\n context.arc(x, y, radius, 0, 2 * Math.PI, false);\n if (this.targetX !== undefined && this.targetY !== undefined &&\n context.isPointInPath(this.targetX, this.targetY)) {\n this.currentTargetShapeId = shapeid;\n }\n if (lineColor !== undefined) {\n context.stroke();\n }\n if (fillColor !== undefined) {\n context.fill();\n }\n },\n\n _drawPieSlice: function (shapeid, x, y, radius, startAngle, endAngle, lineColor, fillColor) {\n var context = this._getContext(lineColor, fillColor);\n context.beginPath();\n context.moveTo(x, y);\n context.arc(x, y, radius, startAngle, endAngle, false);\n context.lineTo(x, y);\n context.closePath();\n if (lineColor !== undefined) {\n context.stroke();\n }\n if (fillColor) {\n context.fill();\n }\n if (this.targetX !== undefined && this.targetY !== undefined &&\n context.isPointInPath(this.targetX, this.targetY)) {\n this.currentTargetShapeId = shapeid;\n }\n },\n\n _drawRect: function (shapeid, x, y, width, height, lineColor, fillColor) {\n return this._drawShape(shapeid, [[x, y], [x + width, y], [x + width, y + height], [x, y + height], [x, y]], lineColor, fillColor);\n },\n\n appendShape: function (shape) {\n this.shapes[shape.id] = shape;\n this.shapeseq.push(shape.id);\n this.lastShapeId = shape.id;\n return shape.id;\n },\n\n replaceWithShape: function (shapeid, shape) {\n var shapeseq = this.shapeseq,\n i;\n this.shapes[shape.id] = shape;\n for (i = shapeseq.length; i--;) {\n if (shapeseq[i] == shapeid) {\n shapeseq[i] = shape.id;\n }\n }\n delete this.shapes[shapeid];\n },\n\n replaceWithShapes: function (shapeids, shapes) {\n var shapeseq = this.shapeseq,\n shapemap = {},\n sid, i, first;\n\n for (i = shapeids.length; i--;) {\n shapemap[shapeids[i]] = true;\n }\n for (i = shapeseq.length; i--;) {\n sid = shapeseq[i];\n if (shapemap[sid]) {\n shapeseq.splice(i, 1);\n delete this.shapes[sid];\n first = i;\n }\n }\n for (i = shapes.length; i--;) {\n shapeseq.splice(first, 0, shapes[i].id);\n this.shapes[shapes[i].id] = shapes[i];\n }\n\n },\n\n insertAfterShape: function (shapeid, shape) {\n var shapeseq = this.shapeseq,\n i;\n for (i = shapeseq.length; i--;) {\n if (shapeseq[i] === shapeid) {\n shapeseq.splice(i + 1, 0, shape.id);\n this.shapes[shape.id] = shape;\n return;\n }\n }\n },\n\n removeShapeId: function (shapeid) {\n var shapeseq = this.shapeseq,\n i;\n for (i = shapeseq.length; i--;) {\n if (shapeseq[i] === shapeid) {\n shapeseq.splice(i, 1);\n break;\n }\n }\n delete this.shapes[shapeid];\n },\n\n getShapeAt: function (el, x, y) {\n this.targetX = x;\n this.targetY = y;\n this.render();\n return this.currentTargetShapeId;\n },\n\n render: function () {\n var shapeseq = this.shapeseq,\n shapes = this.shapes,\n shapeCount = shapeseq.length,\n context = this._getContext(),\n shapeid, shape, i;\n context.clearRect(0, 0, this.pixelWidth, this.pixelHeight);\n for (i = 0; i < shapeCount; i++) {\n shapeid = shapeseq[i];\n shape = shapes[shapeid];\n this['_draw' + shape.type].apply(this, shape.args);\n }\n if (!this.interact) {\n // not interactive so no need to keep the shapes array\n this.shapes = {};\n this.shapeseq = [];\n }\n }\n\n });\n\n VCanvas_vml = createClass(VCanvas_base, {\n init: function (width, height, target) {\n var groupel;\n VCanvas_vml._super.init.call(this, width, height, target);\n if (target[0]) {\n target = target[0];\n }\n $.data(target, '_jqs_vcanvas', this);\n this.canvas = document.createElement('span');\n $(this.canvas).css({ display: 'inline-block', position: 'relative', overflow: 'hidden', width: width, height: height, margin: '0px', padding: '0px', verticalAlign: 'top'});\n this._insert(this.canvas, target);\n this._calculatePixelDims(width, height, this.canvas);\n this.canvas.width = this.pixelWidth;\n this.canvas.height = this.pixelHeight;\n groupel = '';\n this.canvas.insertAdjacentHTML('beforeEnd', groupel);\n this.group = $(this.canvas).children()[0];\n this.rendered = false;\n this.prerender = '';\n },\n\n _drawShape: function (shapeid, path, lineColor, fillColor, lineWidth) {\n var vpath = [],\n initial, stroke, fill, closed, vel, plen, i;\n for (i = 0, plen = path.length; i < plen; i++) {\n vpath[i] = '' + (path[i][0]) + ',' + (path[i][1]);\n }\n initial = vpath.splice(0, 1);\n lineWidth = lineWidth === undefined ? 1 : lineWidth;\n stroke = lineColor === undefined ? ' stroked=\"false\" ' : ' strokeWeight=\"' + lineWidth + 'px\" strokeColor=\"' + lineColor + '\" ';\n fill = fillColor === undefined ? ' filled=\"false\"' : ' fillColor=\"' + fillColor + '\" filled=\"true\" ';\n closed = vpath[0] === vpath[vpath.length - 1] ? 'x ' : '';\n vel = '' +\n ' ';\n return vel;\n },\n\n _drawCircle: function (shapeid, x, y, radius, lineColor, fillColor, lineWidth) {\n var stroke, fill, vel;\n x -= radius;\n y -= radius;\n stroke = lineColor === undefined ? ' stroked=\"false\" ' : ' strokeWeight=\"' + lineWidth + 'px\" strokeColor=\"' + lineColor + '\" ';\n fill = fillColor === undefined ? ' filled=\"false\"' : ' fillColor=\"' + fillColor + '\" filled=\"true\" ';\n vel = '';\n return vel;\n\n },\n\n _drawPieSlice: function (shapeid, x, y, radius, startAngle, endAngle, lineColor, fillColor) {\n var vpath, startx, starty, endx, endy, stroke, fill, vel;\n if (startAngle === endAngle) {\n return ''; // VML seems to have problem when start angle equals end angle.\n }\n if ((endAngle - startAngle) === (2 * Math.PI)) {\n startAngle = 0.0; // VML seems to have a problem when drawing a full circle that doesn't start 0\n endAngle = (2 * Math.PI);\n }\n\n startx = x + Math.round(Math.cos(startAngle) * radius);\n starty = y + Math.round(Math.sin(startAngle) * radius);\n endx = x + Math.round(Math.cos(endAngle) * radius);\n endy = y + Math.round(Math.sin(endAngle) * radius);\n\n if (startx === endx && starty === endy) {\n if ((endAngle - startAngle) < Math.PI) {\n // Prevent very small slices from being mistaken as a whole pie\n return '';\n }\n // essentially going to be the entire circle, so ignore startAngle\n startx = endx = x + radius;\n starty = endy = y;\n }\n\n if (startx === endx && starty === endy && (endAngle - startAngle) < Math.PI) {\n return '';\n }\n\n vpath = [x - radius, y - radius, x + radius, y + radius, startx, starty, endx, endy];\n stroke = lineColor === undefined ? ' stroked=\"false\" ' : ' strokeWeight=\"1px\" strokeColor=\"' + lineColor + '\" ';\n fill = fillColor === undefined ? ' filled=\"false\"' : ' fillColor=\"' + fillColor + '\" filled=\"true\" ';\n vel = '' +\n ' ';\n return vel;\n },\n\n _drawRect: function (shapeid, x, y, width, height, lineColor, fillColor) {\n return this._drawShape(shapeid, [[x, y], [x, y + height], [x + width, y + height], [x + width, y], [x, y]], lineColor, fillColor);\n },\n\n reset: function () {\n this.group.innerHTML = '';\n },\n\n appendShape: function (shape) {\n var vel = this['_draw' + shape.type].apply(this, shape.args);\n if (this.rendered) {\n this.group.insertAdjacentHTML('beforeEnd', vel);\n } else {\n this.prerender += vel;\n }\n this.lastShapeId = shape.id;\n return shape.id;\n },\n\n replaceWithShape: function (shapeid, shape) {\n var existing = $('#jqsshape' + shapeid),\n vel = this['_draw' + shape.type].apply(this, shape.args);\n existing[0].outerHTML = vel;\n },\n\n replaceWithShapes: function (shapeids, shapes) {\n // replace the first shapeid with all the new shapes then toast the remaining old shapes\n var existing = $('#jqsshape' + shapeids[0]),\n replace = '',\n slen = shapes.length,\n i;\n for (i = 0; i < slen; i++) {\n replace += this['_draw' + shapes[i].type].apply(this, shapes[i].args);\n }\n existing[0].outerHTML = replace;\n for (i = 1; i < shapeids.length; i++) {\n $('#jqsshape' + shapeids[i]).remove();\n }\n },\n\n insertAfterShape: function (shapeid, shape) {\n var existing = $('#jqsshape' + shapeid),\n vel = this['_draw' + shape.type].apply(this, shape.args);\n existing[0].insertAdjacentHTML('afterEnd', vel);\n },\n\n removeShapeId: function (shapeid) {\n var existing = $('#jqsshape' + shapeid);\n this.group.removeChild(existing[0]);\n },\n\n getShapeAt: function (el, x, y) {\n var shapeid = el.id.substr(8);\n return shapeid;\n },\n\n render: function () {\n if (!this.rendered) {\n // batch the intial render into a single repaint\n this.group.innerHTML = this.prerender;\n this.rendered = true;\n }\n }\n });\n\n}))}(document, Math));\n", "import './vendor';\nimport 'jquery-sparkline';\nimport { authFetch } from './authWrap';\nimport { error, log } from './logger';\n\ninterface GpuInfo {\n name: string;\n data: Record;\n chart?: [number, number];\n}\n\nlet gpuInterval: ReturnType | null = null;\nconst chartData: { mem: number[]; load: number[] } = { mem: [], load: [] };\n\nasync function updateGPUChart(mem: number, load: number): Promise {\n const maxLen = 120;\n const colorRangeMap = $.range_map({\n '0:5': '#fffafa',\n '6:10': '#fff7ed',\n '11:20': '#fed7aa',\n '21:30': '#fdba74',\n '31:40': '#fb923c',\n '41:50': '#f97316',\n '51:60': '#ea580c',\n '61:70': '#c2410c',\n '71:80': '#9a3412',\n '81:90': '#7c2d12',\n '91:100': '#6c2e12',\n });\n const sparklineConfigLOAD = { type: 'bar', height: '128px', barWidth: '3px', barSpacing: '1px', chartRangeMin: 0, chartRangeMax: 100, barColor: '#89007D' };\n const sparklineConfigMEM = { type: 'bar', height: '128px', barWidth: '3px', barSpacing: '1px', chartRangeMin: 0, chartRangeMax: 100, colorMap: colorRangeMap, composite: true };\n if (chartData.load.length > maxLen) chartData.load.shift();\n chartData.load.push(load);\n if (chartData.mem.length > maxLen) chartData.mem.shift();\n chartData.mem.push(mem);\n $('#gpuChart').sparkline(chartData.load, sparklineConfigLOAD);\n $('#gpuChart').sparkline(chartData.mem, sparklineConfigMEM);\n}\n\nasync function updateGPU(): Promise {\n const gpuEl = document.getElementById('gpu');\n const gpuTable = document.getElementById('gpu-table');\n if (!gpuEl || !gpuTable) return;\n try {\n const res = await authFetch(`${window.api}/gpu-smi`);\n if (!res || !res.ok) {\n clearInterval(gpuInterval);\n gpuEl.style.display = 'none';\n return;\n }\n const data = (await res.json()) as GpuInfo[];\n if (!data) {\n clearInterval(gpuInterval);\n gpuEl.style.display = 'none';\n return;\n }\n const gpuTbody = gpuTable.querySelector('tbody');\n if (!gpuTbody) return;\n let gpu = { data: {} } as GpuInfo;\n if (Array.isArray(data) && data.length >= 1) gpu = data[0];\n let rows = `GPU${gpu.name || 'unknown'}`;\n for (const item of Object.entries(gpu.data)) rows += `${item[0]}${item[1]}`;\n gpuTbody.innerHTML = rows;\n if (gpu.chart && gpu.chart.length === 2) updateGPUChart(gpu.chart[0], gpu.chart[1]);\n gpuEl.style.display = 'block';\n } catch (e) {\n error('updateGPU', e);\n clearInterval(gpuInterval);\n gpuEl.style.display = 'none';\n }\n}\n\nexport async function startGPU(): Promise {\n const gpuEl = document.getElementById('gpu');\n if (!gpuEl) return;\n gpuEl.style.display = 'block';\n if (gpuInterval) clearInterval(gpuInterval);\n const interval = window.opts?.gpu_monitor || 3000;\n log('startGPUmonitor', interval);\n gpuInterval = setInterval(updateGPU, interval);\n updateGPU();\n}\n\nwindow.startGPU = startGPU;\n\nexport async function disableGPU(): Promise {\n clearInterval(gpuInterval);\n const gpuEl = document.getElementById('gpu');\n if (gpuEl) gpuEl.style.display = 'none';\n}\n\nwindow.disableGPU = disableGPU;\n"], + "mappings": "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", "names": ["global", "window", "i", "jQuery", "arr", "matches", "escape", "value", "document", "dir", "parent", "hash", "preFilter", "token", "find", "elem", "self", "add", "deferred", "process", "error", "data", "el", "nodeName", "event", "name", "schedule", "opts", "index", "length", "timers", "timer", "location", "val", "url", "completed", "done", "method", "type", "undefined", "requestAnimationFrame", "timer", "addEventListener", "el", "log", "event", "iframeId", "location", "hash", "error", "MutationObserver", "options", "isVisible", "$", "e", "t", "i", "n", "s", "r", "a", "o", "l", "h", "u", "c", "f", "d", "K", "$", "eventify", "subject", "validateSubject", "eventsStorage", "createEventsStorage", "registeredEvents", "eventName", "callback", "ctx", "handlers", "callbacks", "fireArguments", "i", "callbackInfo", "reservedWords", "cancelAnimationFrame", "requestAnimationFrame", "isNaN", "parent", "onKeyDown", "el", "jQuery", "el", "url", "url", "event", "el", "isVisible", "el", "el", "el", "event", "el", "el", "event", "el", "el", "ok", "el", "gallerySelection", "updateInput", "active", "el", "el", "el", "updateInput", "updateInput", "event", "hash", "atBottom", "el", "parent", "el", "el", "Hash", "HMAC", "hash", "hmac", "ok", "parent", "event", "el", "modalImage", "modal", "gallerySelection", "event", "exifr", "Panzoom", "updateInput", "el", "el", "el", "event", "appendContextMenuOption", "removeContextMenuOption", "addContextMenuEventListener", "busy", "el", "el", "url", "ok", "url", "updateInput", "el", "el", "url", "url", "ts", "el", "delay", "event", "updateInput", "document", "Math", "undefined", "$", "format", "self", "token", "el", "width", "height", "target", "interact", "shapeCount"] } diff --git a/ui/extraNetworks.ts b/ui/extraNetworks.ts index 35f074d52..feb10356f 100644 --- a/ui/extraNetworks.ts +++ b/ui/extraNetworks.ts @@ -4,12 +4,17 @@ import { authFetch } from './authWrap'; import { timer } from './timers'; const activePromptTextarea = {}; +const selectedNetworks = {}; let sortVal = -1; let totalCards = -1; let lastTab = 'control'; // helpers +export function getSelectedNetworks() { + return selectedNetworks; +} + export const getENActiveTab = () => { let tabName = ''; if (gradioApp().getElementById('txt2img_prompt')?.checkVisibility() || gradioApp().getElementById('txt2img_generate')?.checkVisibility()) tabName = 'txt2img'; @@ -307,6 +312,7 @@ function refreshENInput(tabName) { export async function markSelectedCards(selected, page = '') { log('markSelectedCards', selected, page); + selectedNetworks[page] = selected; gradioApp().querySelectorAll('.extra-network-cards .card').forEach((el) => { if (page.length > 0 && el.dataset.page !== page) return; // filter by page if (selected.includes(el.dataset.name) || selected.includes(el.dataset.short)) el.classList.add('card-selected'); @@ -660,6 +666,7 @@ window.applyStyles = applyStyles; window.closeDetailsEN = closeDetailsEN; window.getENActivePage = getENActivePage; window.getCardDetails = getCardDetails; +window.getSelectedNetworks = getSelectedNetworks; window.sortExtraNetworks = sortExtraNetworks; window.refeshDetailsEN = refeshDetailsEN; window.extraNetworksSearchButton = extraNetworksSearchButton; diff --git a/ui/gallery.ts b/ui/gallery.ts index 8b7e07e4c..f82839277 100644 --- a/ui/gallery.ts +++ b/ui/gallery.ts @@ -34,7 +34,6 @@ const minCleanupCount = 1000; const minCleanupTime = 1000 * 60 * 60; // 1 hour const folderStylesheet = new CSSStyleSheet(); const fileStylesheet = new CSSStyleSheet(); -const iconStopwatch = String.fromCodePoint(9201); // Store separator states for the session const separatorStates = new Map(); const el = { @@ -49,6 +48,12 @@ const el = { const cleanupTimers = {}; const maintenanceTimers = {}; const fetchQueue = []; +const icons = { + Time: String.fromCodePoint(9201), + Folder: String.fromCodePoint(128448), // or 128449; + Sort: String.fromCodePoint(8645), + Images: String.fromCodePoint(128461), +}; const SUPPORTED_EXTENSIONS = ['jpg', 'jpeg', 'png', 'webp', 'tiff', 'jp2', 'jxl', 'gif', 'mp4', 'mkv', 'avi', 'mjpeg', 'mpg', 'avr']; @@ -63,6 +68,17 @@ const gallerySorter = { modA: { name: 'Modified Descending', func: (b, a) => a.mtime - b.mtime }, none: { name: 'None', func: undefined }, }; +const folderSorter = { + nameA: { name: 'Name Ascending', func: (a, b) => a.name.localeCompare(b.name) }, + nameD: { name: 'Name Descending', func: (b, a) => a.name.localeCompare(b.name) }, + sizeD: { name: 'Size Ascending', func: (a, b) => a.size - b.size }, + sizeA: { name: 'Size Descending', func: (b, a) => a.size - b.size }, + resD: { name: 'Resolution Ascending', func: (a, b) => a.width * a.height - b.width * b.height }, + resA: { name: 'Resolution Descending', func: (b, a) => a.width * a.height - b.width * b.height }, + modD: { name: 'Modified Ascending', func: (a, b) => a.mtime - b.mtime }, + modA: { name: 'Modified Descending', func: (b, a) => a.mtime - b.mtime }, + none: { name: 'None', func: undefined }, +}; let sortMode = gallerySorter.none; @@ -225,9 +241,9 @@ function updateGalleryStyles() { padding: 4px; font-size: 1.2em; letter-spacing: 0.5em; - width: 140px; margin-top: calc(140px - 32px); opacity: 75%; + border-radius: var(--sd-border-radius); } :host(.gallery-file-selected) .gallery-file { box-shadow: 0 0 0 2px var(--sd-button-selected-color); @@ -278,7 +294,6 @@ class SimpleProgressBar { this.#progress.style.backgroundColor = 'var(--sd-main-accent-color)'; this.#textDiv.style.cssText = 'position:relative; margin:auto; width:max-content; height:100%;'; this.#text.style.cssText = 'user-select:none; color:white;'; - this.#textDiv.append(this.#text); this.#container.append(this.#progress, this.#textDiv); } @@ -287,6 +302,10 @@ class SimpleProgressBar { if (total <= 0) return; this.hide(); this.#max = total; + if (this.#monitoredSet.size >= this.#max) { + this.stop(); + return; + } this.#interval = setInterval(() => this.update(this.#monitoredSet.size, this.#max), 100); } @@ -314,7 +333,7 @@ class SimpleProgressBar { stop() { clearInterval(this.#interval); - this.#interval = undefined; + // this.#interval = undefined; if (this.stats.count) { debug('gallery: thumbnail stats', this.stats); this.stats = { ...this.defaultStats }; @@ -629,7 +648,7 @@ class GalleryFile extends HTMLElement { img.title = `Folder: ${this.folder}\nFile: ${this.name}\nSize: ${this.size.toLocaleString()} bytes\nModified: ${this.mtime.toLocaleString()}`; this.title = img.title; const shouldDisplayBasedOnSearch = this.title.toLowerCase().includes(el.search.value.toLowerCase()); // Final visibility check based on search term. - if (this.style.display !== 'none') this.style.display = shouldDisplayBasedOnSearch ? 'flex' : 'none'; // Only proceed if not already hidden by a closed separator + if (this.style.display !== 'none') this.style.display = shouldDisplayBasedOnSearch ? '' : 'none'; // Only proceed if not already hidden by a closed separator this.shadow.appendChild(img); pb.stats.elapsed = (pb.stats.elapsed || 0) + Math.round(performance.now() - t0); } @@ -674,7 +693,7 @@ async function handleSeparator(separator) { const fileDirPath = fileDir ? fileDir[1] : ''; if (separator.title.length > 0 && fileDirPath === separator.title) { - f.style.display = nowHidden ? 'none' : 'unset'; + f.style.display = nowHidden ? 'none' : ''; } } // Note: Count is not updated here on manual toggle, as it reflects the total. @@ -774,24 +793,22 @@ window.gallerySendImage = gallerySendImage; * @param {...string|[string, string]} messages - Each can be either a string to use as-is, or an array of a string label and value * @returns {void} */ -function updateStatusWithSort(...messages) { +function updateStatusLine(...messages) { if (!el.status) return; messages.unshift(['Sort', sortMode.name]); const fragment = document.createDocumentFragment(); for (let i = 0; i < messages.length; i++) { const div = document.createElement('div'); if (Array.isArray(messages[i])) { - const [text1, text2] = messages[i]; - const tDiv1 = document.createElement('div'); - tDiv1.innerText = `${text1}:`; - const tDiv2 = document.createElement('div'); - tDiv2.innerText = text2; - tDiv2.title = text2; - div.append(tDiv1, tDiv2); + const [k, v] = messages[i]; + const tDiv = document.createElement('div'); + const ico = icons[k] || `${k}:`; + tDiv.innerText = `${ico} ${v}`; + div.append(tDiv); } else { - const tDiv1 = document.createElement('div'); - tDiv1.innerText = messages[i]; - div.append(tDiv1); + const tDiv = document.createElement('div'); + tDiv.innerText = messages[i]; + div.append(tDiv); } fragment.append(div); } @@ -878,7 +895,7 @@ async function gallerySearch() { f.style.display = (!dirPath || isOpen) ? 'unset' : 'none'; }); - updateStatusWithSort('Filter', 'Cleared', ['Images', allFiles.length.toLocaleString()]); + updateStatusLine('Filter', 'Cleared', ['Images', allFiles.length.toLocaleString()]); return; } @@ -936,7 +953,7 @@ async function gallerySearch() { } const t1 = performance.now(); - updateStatusWithSort('Filter', ['Images', `${totalFound.toLocaleString()} / ${allFiles.length.toLocaleString()}`], `${iconStopwatch} ${Math.round(t1 - t0).toLocaleString()}ms`); + updateStatusLine('Filter', ['Images', `${totalFound.toLocaleString()} / ${allFiles.length.toLocaleString()}`], ['Time', `${Math.round(t1 - t0).toLocaleString()}ms`]); timer(`galleryFilter:${str}`, t1 - t0); refreshGallerySelection(); }, 250); @@ -981,9 +998,7 @@ export async function gallerySort(key) { const folderGroups = new Map(); for (const file of subfolderFiles) { const dir = getDirPath(file); - if (!folderGroups.has(dir)) { - folderGroups.set(dir, []); - } + if (!folderGroups.has(dir)) folderGroups.set(dir, []); folderGroups.get(dir).push(file); } @@ -994,7 +1009,11 @@ export async function gallerySort(key) { rootFiles.forEach((node) => fragment.appendChild(node)); // Sort folder names alphabetically, then sort files within each folder - const sortedFolderNames = Array.from(folderGroups.keys()).sort((a, b) => a.localeCompare(b)); + // const sortedFolderNames = Array.from(folderGroups.keys()).sort((a, b) => a.localeCompare(b)); + const folderNames = Array.from(folderGroups.keys()); + const sortedFolderNames = currentSort.endsWith('A') ? folderNames.sort((a, b) => a.localeCompare(b)) : folderNames.sort((a, b) => b.localeCompare(a)); + + console.log('HERE', sortedFolderNames); for (const folderName of sortedFolderNames) { const files = folderGroups.get(folderName); files.sort(sortMode.func); @@ -1023,7 +1042,7 @@ export async function gallerySort(key) { const t1 = performance.now(); log(`gallerySort: sort=${sortMode.name} len=${arr.length} time=${Math.floor(t1 - t0)}`); - updateStatusWithSort(['Images', arr.length.toLocaleString()], `${iconStopwatch} ${Math.round(t1 - t0).toLocaleString()}ms`); + updateStatusLine(['Images', arr.length.toLocaleString()], ['Time', `${Math.round(t1 - t0).toLocaleString()}ms`]); timer(`gallerySort:${sortMode.name}`, t1 - t0); refreshGallerySelection(); } @@ -1120,7 +1139,7 @@ async function thumbCacheCleanup(folder, imgCount, controller, force = false) { log('galleryMaintenance', { folder, kept: keptGalleryHashes.size, deleted: delcount, time: Math.round(t1 - t0) }); timer(`thumbnailDBCleanup:${folder}`, t1 - t0); currentGalleryFolder = null; - updateStatusWithSort('Thumbnail cache cleared'); + updateStatusLine('Thumbnail cache cleared'); }) .catch((reason) => { SimpleFunctionQueue.abortLogger('thumbCacheCleanup', reason); @@ -1157,7 +1176,7 @@ function clearCacheIfDisabled(browser_cache) { .then(() => { log('thumbCacheCleanup', { time: Math.floor(performance.now() - t0) }); currentGalleryFolder = null; - updateStatusWithSort('Thumbnail cache cleared'); + updateStatusLine('Thumbnail cache cleared'); }) .catch((e) => { SimpleFunctionQueue.abortLogger('thumbCacheCleanup', e); @@ -1183,12 +1202,12 @@ window.clearCache = clearCache; async function fetchFilesHT(evt, controller) { const t0 = performance.now(); const fragment = document.createDocumentFragment(); - updateStatusWithSort(['Folder', evt.target.name], 'in-progress'); + updateStatusLine(['Folder', evt.target.name], 'in-progress'); let numFiles = 0; const res = await authFetch(`${window.api}/browser/files?folder=${encodeURI(evt.target.name)}`); if (!res || res.status !== 200) { - updateStatusWithSort(['Folder', evt.target.name], ['Failed', res?.statusText || 'No response']); + updateStatusLine(['Folder', evt.target.name], ['Failed', res?.statusText || 'No response']); return; } const jsonData = await res.json(); @@ -1209,7 +1228,7 @@ async function fetchFilesHT(evt, controller) { const t1 = performance.now(); log(`gallery: folder=${evt.target.name} num=${numFiles} method=http time=${Math.floor(t1 - t0)}ms`); timer(`galleryFetch:${evt.target.name}`, t1 - t0); - updateStatusWithSort(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`); + updateStatusLine(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], ['Time', `${Math.floor(t1 - t0).toLocaleString()}ms`]); pb.start(numFiles); addSeparators(); refreshGallerySelection(); @@ -1238,7 +1257,7 @@ async function fetchFilesWS(evt) { // fetch file-by-file list over websockets await fetchFilesHT(evt, controller); // fallback to http return; } - updateStatusWithSort(['Folder', evt.target.name]); + updateStatusLine(['Folder', evt.target.name]); const t0 = performance.now(); let numFiles = 0; let t1 = performance.now(); @@ -1257,7 +1276,7 @@ async function fetchFilesWS(evt) { // fetch file-by-file list over websockets numFiles++; fragment.appendChild(file); if (numFiles % fragmentSize === 0) { - updateStatusWithSort(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], 'in-progress', `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`); + updateStatusLine(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], ['Status', 'in-progress'], ['Time', `${Math.floor(t1 - t0).toLocaleString()}ms`]); el.files.appendChild(fragment); fragment = document.createDocumentFragment(); } @@ -1269,7 +1288,7 @@ async function fetchFilesWS(evt) { // fetch file-by-file list over websockets el.files.appendChild(fragment); // gallerySort(); log(`gallery: folder=${evt.target.name} num=${numFiles} method=ws time=${Math.floor(t1 - t0)}ms`); - updateStatusWithSort(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], `${iconStopwatch} ${Math.floor(t1 - t0).toLocaleString()}ms`); + updateStatusLine(['Folder', evt.target.name], ['Images', numFiles.toLocaleString()], ['Time', `${Math.floor(t1 - t0).toLocaleString()}ms`]); pb.start(numFiles); addSeparators(); refreshGallerySelection(); @@ -1362,7 +1381,7 @@ async function initGalleryAutoRefresh() { } async function overlayDelete(evt) { - const res = await authFetch(`${window.api}/delete-image?file=${encodeURIComponent(currentImage)}`); + const res = await authFetch(`${window.api}/delete-image?file=${encodeURIComponent(currentImage)}`, { method: 'DELETE' }); evt.stopPropagation(); if (!res || res.status !== 200) { error('galleryDelete', { file: currentImage, status: res?.status, statusText: res?.statusText }); diff --git a/ui/globals.d.ts b/ui/globals.d.ts index d680162a6..150623d1b 100644 --- a/ui/globals.d.ts +++ b/ui/globals.d.ts @@ -102,6 +102,7 @@ declare global { closeDetailsEN?: (...args: unknown[]) => unknown[]; // ui/extraNetworks.ts extraNetworksFilterVersion?: (event: Event) => void; // ui/extraNetworks.ts extraNetworksSearchButton?: (event: Event) => void; // ui/extraNetworks.ts + getSelectedNetworks?: () => Record; // ui/extraNetworks.ts getCardDetails?: (...args: unknown[]) => unknown[]; // ui/extraNetworks.ts quickSaveStyle?: () => void; // ui/extraNetworks.ts getENActivePage?: () => string; // ui/extraNetworks.ts diff --git a/ui/gpu.ts b/ui/gpu.ts index 82b55656f..bade7d851 100644 --- a/ui/gpu.ts +++ b/ui/gpu.ts @@ -56,12 +56,12 @@ async function updateGPU(): Promise { } const gpuTbody = gpuTable.querySelector('tbody'); if (!gpuTbody) return; - for (const gpu of data) { - let rows = `GPU${gpu.name}`; - for (const item of Object.entries(gpu.data)) rows += `${item[0]}${item[1]}`; - gpuTbody.innerHTML = rows; - if (gpu.chart && gpu.chart.length === 2) updateGPUChart(gpu.chart[0], gpu.chart[1]); - } + let gpu = { data: {} } as GpuInfo; + if (Array.isArray(data) && data.length >= 1) gpu = data[0]; + let rows = `GPU${gpu.name || 'unknown'}`; + for (const item of Object.entries(gpu.data)) rows += `${item[0]}${item[1]}`; + gpuTbody.innerHTML = rows; + if (gpu.chart && gpu.chart.length === 2) updateGPUChart(gpu.chart[0], gpu.chart[1]); gpuEl.style.display = 'block'; } catch (e) { error('updateGPU', e); @@ -76,7 +76,7 @@ export async function startGPU(): Promise { gpuEl.style.display = 'block'; if (gpuInterval) clearInterval(gpuInterval); const interval = window.opts?.gpu_monitor || 3000; - log('startGPU', interval); + log('startGPUmonitor', interval); gpuInterval = setInterval(updateGPU, interval); updateGPU(); } diff --git a/ui/loader.ts b/ui/loader.ts index 547f62b45..c20b241bc 100644 --- a/ui/loader.ts +++ b/ui/loader.ts @@ -102,7 +102,10 @@ async function createSplash() { .then((res) => res.text()) .then((text) => { const clean = text.replace(/["]+/g, ''); - log('getMOTD', clean); + const boldMatch = clean.match(/(.*?)<\/b>/); + const boldText = boldMatch ? boldMatch[1] : clean; + if (boldMatch) log('getMOTD', { version: boldText }); + else log('getMOTD', { text: clean }); const motdEl = document.getElementById('motd'); if (motdEl) motdEl.innerHTML = clean; }) diff --git a/ui/locale/locale_en.json b/ui/locale/locale_en.json index 8ec96e8d4..584f8a49b 100644 --- a/ui/locale/locale_en.json +++ b/ui/locale/locale_en.json @@ -47,7 +47,7 @@ {"id":"quicksettings_clear","label":"⊗","localized":"","hint":"Reset values"}, {"id":"docs_btn_search","label":"🔍","localized":"","hint":"Search","ui":"system_tab_docs"}, {"id":"component-5667","label":"⇨","localized":"","hint":"Apply preset","ui":"component-5660"}, - {"id":"txt2img_extra_model","label":"※","localized":"","hint":"Load model as refiner model when selected, otherwise load as base model"}, + {"id":"txt2img_extra_model","label":"※","localized":"","hint":"Load model as secondary model when selected, otherwise load as base model"}, {"id":"txt2img_extra_scan","label":"🔎︎","localized":"","hint":"Scan CivitAI for missing metadata and previews"}, {"id":"txt2img_extra_sort","label":"⇕","localized":"","hint":"Sort by: Name asc/desc, Size largest/smallest, Time newest/oldest"}, {"id":"txt2img_extra_close","label":"✕","localized":"","hint":"Close"}, @@ -1561,6 +1561,7 @@ {"id":"","label":"Use spaces","localized":"","hint":"Replace underscores with spaces in tag output.
    Some prompt systems prefer spaces between words (e.g., 'long hair') while others use underscores (e.g., 'long_hair').","ui":"caption"}, {"id":"","label":"Username","localized":"","hint":"","ui":"component-8823"}, {"id":"","label":"UNET model","localized":"","hint":"","ui":"settings_sd"}, + {"id":"","label":"UNET model secondary","localized":"","hint":"Override for the second transformer of dual-transformer architectures:
    - Ideogram 4: the unconditional transformer
    - Wan combined stage: the second expert (transformer_2)

    Shown only when the loaded model has a second transformer.
    Default loads the component from the base model.","ui":"settings_sd"}, {"id":"","label":"Use torch streams","localized":"","hint":"In group offload, uses CUDA streams to prefetch the next group while the current one runs, hiding transfer latency.
    Faster, but uses more VRAM.

    Applies only to group offload.

    Disabled by default.","reload":"model","ui":"settings_offload"}, {"id":"","label":"Use SVD quantization","localized":"","hint":"Adds a low-rank (SVDQuant) correction on top of SDNQ to recover accuracy lost at low bit widths, at the cost of extra size and compute.
    Tuned by SVD rank size and SVD steps.

    Disabled by default.","reload":"model","ui":"settings_quantization"}, {"id":"","label":"Use Dynamic quantization","localized":"","hint":"Picks a per-layer weight type automatically instead of one type everywhere. Each layer starts at the Quantization type (the minimum) and steps up to higher precision until its error meets the Dynamic loss threshold.
    Protects error-sensitive layers at the cost of a larger model and slower load.

    Disabled by default.","reload":"model","ui":"settings_quantization"}, diff --git a/ui/logMonitor.ts b/ui/logMonitor.ts index fcbda70f5..866a75ab0 100644 --- a/ui/logMonitor.ts +++ b/ui/logMonitor.ts @@ -18,14 +18,15 @@ let logConnected = false; function dateToStr(ts: number): string { const dt = new Date(1000 * ts); - const year = dt.getFullYear(); - const mo = String(dt.getMonth() + 1).padStart(2, '0'); - const day = String(dt.getDate()).padStart(2, '0'); + // const year = dt.getFullYear(); + // const mo = String(dt.getMonth() + 1).padStart(2, '0'); + // const day = String(dt.getDate()).padStart(2, '0'); const hour = String(dt.getHours()).padStart(2, '0'); const min = String(dt.getMinutes()).padStart(2, '0'); const sec = String(dt.getSeconds()).padStart(2, '0'); const ms = String(dt.getMilliseconds()).padStart(3, '0'); - const s = `${year}-${mo}-${day} ${hour}:${min}:${sec}.${ms}`; + // const s = `${year}-${mo}-${day} ${hour}:${min}:${sec}.${ms}`; + const s = `${hour}:${min}:${sec}.${ms}`; return s; } @@ -47,6 +48,23 @@ function parseLogLine(line: string): LogLine { }; } +async function clearErrors(): Promise { + logWarnings = 0; + logErrors = 0; + log('clearErrors'); +} + +export async function initClearErrorsButton() { + const btnServerClear = document.getElementById('btn_console_log_server_clear'); + if (btnServerClear) { + btnServerClear.onclick = async (evt) => { + evt.preventDefault(); + evt.stopPropagation(); + clearErrors(); + }; + } +} + async function logMonitor() { const addLogLine = (line: string): void => { if (!logMonitorEl) logMonitorEl = document.getElementById('logMonitorData'); @@ -58,14 +76,13 @@ async function logMonitor() { const level = `${l.level}`; if (l.level === 'WARNING') logWarnings++; if (l.level === 'ERROR') logErrors++; - const module = `${l.module}`; + const module = `${l.module}`; const facilityText = l.facility.length > 20 ? `${l.facility.substring(0, 20)}...` : l.facility; - const facility = l.facility !== 'sd' ? `${facilityText}` : ''; + const facility = l.facility !== 'sd' ? `${facilityText}` : ''; row.innerHTML = `${dateToStr(l.created)}${level}${facility}${module}${htmlEscape(l.msg)}`; logMonitorEl.appendChild(row); } catch (err) { - error(`logMonitor: ${String(err)}`); - error(`logMonitor: ${line}`); + error('logMonitor', { error: String(err), line }); } }; @@ -81,7 +98,11 @@ async function logMonitor() { const modenUIBtn = document.getElementById('btn_console'); if (elWarn) elWarn.innerText = String(logWarnings); if (elErr) elErr.innerText = String(logErrors); - if (modenUIBtn) modenUIBtn.setAttribute('error-count', logErrors > 0 ? String(logErrors) : ''); + if (modenUIBtn) { + modenUIBtn.setAttribute('error-count', logErrors > 0 ? String(logErrors) : ''); + modenUIBtn.style.backgroundColor = logErrors > 0 ? 'var(--color-error)' : ''; + modenUIBtn.title = `Log\nErrors ${logErrors}\nWarnings ${logWarnings}`; + } }; const txtGallery = document.getElementById('txt2img_gallery'); @@ -111,6 +132,7 @@ async function logMonitor() { } if (!logMonitorEl) return; const atBottom = logMonitorEl.scrollHeight <= (logMonitorEl.scrollTop + logMonitorEl.clientHeight); + try { const res = await authFetch(`${window.api}/log?clear=True`); if (res?.ok) { @@ -119,52 +141,67 @@ async function logMonitor() { if (logMonitorEl && lines?.length > 0 && logMonitorEl.parentElement?.parentElement instanceof HTMLElement) { logMonitorEl.parentElement.parentElement.style.display = window.opts.logmonitor_show ? 'block' : 'none'; } - for (const line of lines) addLogLine(line); if (!logConnected) { logConnected = true; xhrPost(`${window.api}/log`, { debug: 'connected' }); + logErrors = 0; // reset error count on reconnect } + for (const line of lines) addLogLine(line); } else { logConnected = false; logErrors++; - addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Failed to fetch log: ${res?.status} ${res?.statusText}" }`); + if (res) addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Failed to fetch log: ${res?.status} ${res?.statusText}" }`); + else addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Server unreachable" }`); } cleanupLog(atBottom); } catch { logConnected = false; logErrors++; - addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Failed to fetch log: server unreachable" }`); + addLogLine(`{ "created": ${Date.now()}, "level":"ERROR", "module":"logMonitor", "facility":"ui", "msg":"Server unreachable" }`); cleanupLog(atBottom); } } export async function initLogMonitor() { - const el = document.getElementsByTagName('footer')[0]; + let el = document.getElementById('logMonitorPlaceholder'); + const modernUi = Boolean(el); + if (!el) el = document.getElementsByTagName('footer')[0]; if (!el) return; const t0 = performance.now(); el.classList.add('log-monitor'); const uiDisabled = Array.isArray(window.opts.ui_disabled) ? window.opts.ui_disabled : []; if (uiDisabled.includes('logs')) return; - el.innerHTML = ` - - - - - - - - - - - - - - -
    TimeLevelModuleMessageWarnings 0Errors 0
    - `; + if (modernUi) { + el.style.overflow = 'auto'; + el.innerHTML = ` + + + +
    + `; + } else { + el.innerHTML = ` + + + + + + + + + + + + + + +
    TimeLevelModuleMessageWarnings 0Errors 0
    + `; + } el.style.display = 'none'; authFetch(`${window.api}/start?agent=${encodeURI(navigator.userAgent)}`); logMonitor(); + initClearErrorsButton(); const t1 = performance.now(); log('initLogMonitor', { show: window.opts.logmonitor_show, time: Math.round(t1 - t0) }); timer('initLogMonitor', t1 - t0); diff --git a/ui/progressBar.ts b/ui/progressBar.ts index 158cae277..09fecafaa 100644 --- a/ui/progressBar.ts +++ b/ui/progressBar.ts @@ -9,7 +9,7 @@ const startTimeout = 5; export function setRefreshInterval() { refreshInterval = window.opts.live_preview_refresh_period || 500; - log('refreshInterval', document.visibilityState, refreshInterval); + log('refreshInterval', { visibile: document.visibilityState, interval: refreshInterval }); document.addEventListener('visibilitychange', () => { if (window.opts.live_preview_require_focus !== false && document.hidden) refreshInterval = Math.max(2500, window.opts.live_preview_refresh_period || 1000); else refreshInterval = window.opts.live_preview_refresh_period || 1000; diff --git a/ui/script.ts b/ui/script.ts index 92364ec45..c3c7407a8 100644 --- a/ui/script.ts +++ b/ui/script.ts @@ -273,7 +273,7 @@ export async function deleteFile(filename) { if (!filename) return; // eslint-disable-next-line no-alert if (!confirm(`Are you sure you want to delete the object - This action cannot be undone? Object: ${filename}`)) return; - const res = await authFetch(`${window.api}/delete-file?file=${encodeURIComponent(filename)}`); + const res = await authFetch(`${window.api}/delete-file?file=${encodeURIComponent(filename)}`, { method: 'DELETE' }); if (!res || res.status !== 200) { error('FileDelete', { file: filename, status: res?.status, statusText: res?.statusText }); return; diff --git a/ui/setHints.ts b/ui/setHints.ts index 7732de1fa..be0f19080 100644 --- a/ui/setHints.ts +++ b/ui/setHints.ts @@ -207,7 +207,7 @@ async function getLocaleData(desiredLocale = null) { localeData.locale = desiredLocale || 'en'; localeData.prev = localeData.locale; } - log('getLocale', desiredLocale, localeData.locale); + log('getLocale', { lang: desiredLocale, locale: localeData.locale }); // primary let json: any = {}; try { diff --git a/ui/settings.ts b/ui/settings.ts index 2d50351ee..227ec59b7 100644 --- a/ui/settings.ts +++ b/ui/settings.ts @@ -64,7 +64,7 @@ async function updateOpts(json_string) { else opts_tabs[meta.tab_name].saved_keys.add(opt); }); const t2 = performance.now(); - log('updateOpts', `settings=${Object.keys(new_opts).length} callbacks=${Math.round(t2 - t1)} apply=${Math.round(t1 - t0)}`); + log('updateOpts', { settings: Object.keys(new_opts).length, callbacks: Math.round(t2 - t1), apply: Math.round(t1 - t0) }); timer('updateOpts', t2 - t0); } diff --git a/ui/startup.ts b/ui/startup.ts index e27d51fbf..23513207a 100644 --- a/ui/startup.ts +++ b/ui/startup.ts @@ -57,6 +57,15 @@ async function postStartup() { logTimers(); } +async function updateSubpath() { + log('mountURL', window.opts.subpath); + if (window.opts.subpath?.length > 0) { + window.subpath = window.opts.subpath; + window.api = `${window.subpath}/sdapi/v1`; + } + log('API', { url: window.api }); +} + async function initStartup() { const t0 = performance.now(); log('initGradio', Math.round(t0 - appStartTime)); @@ -82,14 +91,7 @@ async function initStartup() { // reconnect server session await reconnectUI(); await waitForOpts(); - - log('mountURL', window.opts.subpath); - if (window.opts.subpath?.length > 0) { - window.subpath = window.opts.subpath; - window.api = `${window.subpath}/sdapi/v1`; - } - - startupPromises.push(initLogMonitor()); + await updateSubpath(); executeCallbacks(uiReadyCallbacks); @@ -97,6 +99,7 @@ async function initStartup() { if (window.waitForUiReady) await window.waitForUiReady(); // post startup tasks that may take longer but are not critical + startupPromises.push(Promise.resolve(initLogMonitor())); startupPromises.push(Promise.resolve(initGallery())); startupPromises.push(Promise.resolve(setRefreshInterval())); startupPromises.push(Promise.resolve(setupExtraNetworks())); diff --git a/ui/ui.ts b/ui/ui.ts index caf8e995b..d5705d998 100644 --- a/ui/ui.ts +++ b/ui/ui.ts @@ -165,15 +165,14 @@ export function setFontSize(val, old) { rootStyle.setProperty('--text-xxl', `${nextSize + 3}px`); appliedFontSize = nextSize; const t1 = performance.now(); - log('setFontSize', nextSize, `time=${Math.round(t1 - t0)}`); - timer('setFontSize', t1 - t0); + log('setFontSize', { size: nextSize, time: Math.round(t1 - t0) }); }); } function switchToTab(tab) { const tabs = Array.from(gradioApp().querySelectorAll('#tabs > .tab-nav > button')); const btn = tabs?.find((t) => t.innerText === tab); - log('switchToTab', tab); + log('switchToTab', { tab }); if (btn) btn.click(); } @@ -682,8 +681,12 @@ function getDesiredCheckpointName() { export function selectUNet(name) { desiredUNetName = name; - gradioApp().getElementById('change_unet').click(); - log(`selectUNet: ${desiredUNetName}`); + const tabName = getENActiveTab(); + const btnModel = gradioApp().getElementById(`${tabName}_extra_model`); + const isSecondary = btnModel && btnModel.classList.contains('toolbutton-selected'); + if (isSecondary) gradioApp().getElementById('change_unet_secondary').click(); + else gradioApp().getElementById('change_unet').click(); + log(`selectUNet ${isSecondary ? 'secondary' : 'primary'}: ${desiredUNetName}`); markSelectedCards([desiredUNetName], 'unet'); } diff --git a/webui.py b/webui.py index 92ebe6eff..f98202668 100644 --- a/webui.py +++ b/webui.py @@ -184,6 +184,7 @@ def load_model(): shared.opts.onchange("sd_model_refiner", wrap_queued_call(lambda: modules.sd_models.reload_model_weights(op='refiner')), call=False) shared.opts.onchange("sd_vae", wrap_queued_call(lambda: modules.sd_vae.reload_vae_weights()), call=False) shared.opts.onchange("sd_unet", wrap_queued_call(lambda: modules.sd_unet.load_unet(shared.sd_model)), call=False) + shared.opts.onchange("sd_unet_secondary", wrap_queued_call(lambda: modules.sd_unet.load_unet_secondary(shared.sd_model)), call=False) shared.opts.onchange("sd_text_encoder", wrap_queued_call(lambda: modules.sd_models.reload_text_encoder()), call=False) shared.opts.onchange("temp_dir", modules.gr_tempdir.on_tmpdir_changed) timer.startup.record("onchange") @@ -275,6 +276,7 @@ def mount_subpath(app): import gradio if not shared.opts.subpath.startswith('/'): shared.opts.subpath = f'/{shared.opts.subpath}' + shared.cmd_opts.subpath = shared.opts.subpath # update cmd_opts to match opts gradio.mount_gradio_app(app, shared.demo, path=shared.opts.subpath) log.info(f'Mounted: subpath="{shared.opts.subpath}"')