From 0714db1a74d4c07049edb61e63620c0956800155 Mon Sep 17 00:00:00 2001
From: Sam-coder183 <74673264+Sam-coder183@users.noreply.github.com>
Date: Sat, 22 Nov 2025 20:26:05 +0100
Subject: [PATCH 01/21] entity-component systems supported
---
Cargo.toml | 1 +
WINDOWS_SETUP.md | 49 ++
crates/code-analyzer-web/.cargo/config.toml | 5 +
crates/code-analyzer-web/Cargo.toml | 24 +
crates/code-analyzer-web/index.html | 116 +++++
crates/code-analyzer-web/serve.sh | 5 +
crates/code-analyzer-web/src/lib.rs | 455 +++++++++++++++++
crates/demo-core/src/lib.rs | 160 +++++-
crates/demo-core/src/settings.rs | 14 +-
crates/egui_graphs/examples/code_analyzer.rs | 484 +++++++++++++++++++
10 files changed, 1295 insertions(+), 18 deletions(-)
create mode 100644 WINDOWS_SETUP.md
create mode 100644 crates/code-analyzer-web/.cargo/config.toml
create mode 100644 crates/code-analyzer-web/Cargo.toml
create mode 100644 crates/code-analyzer-web/index.html
create mode 100644 crates/code-analyzer-web/serve.sh
create mode 100644 crates/code-analyzer-web/src/lib.rs
create mode 100644 crates/egui_graphs/examples/code_analyzer.rs
diff --git a/Cargo.toml b/Cargo.toml
index 00f0af8..fedf408 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,6 +3,7 @@ members = [
"crates/egui_graphs",
"crates/demo-core",
"crates/demo-web",
+ "crates/code-analyzer-web",
]
resolver = "2"
diff --git a/WINDOWS_SETUP.md b/WINDOWS_SETUP.md
new file mode 100644
index 0000000..9e8cb3b
--- /dev/null
+++ b/WINDOWS_SETUP.md
@@ -0,0 +1,49 @@
+# Running egui_graphs Natively on Windows
+
+## Option 1: Use Web Version (Easiest - Already Working!)
+
+The web version is running at **http://127.0.0.1:8080/**
+- Full functionality including your new color picker feature
+- No additional setup needed
+- Works perfectly from WSL
+
+## Option 2: Install Rust on Windows (For Native Windows App)
+
+1. **Download Rust for Windows:**
+ - Visit: https://rustup.rs/
+ - Download and run `rustup-init.exe`
+ - Follow the installation prompts (default options are fine)
+
+2. **Restart your terminal** (close and reopen PowerShell)
+
+3. **Run the demo:**
+ ```powershell
+ cd "C:\Users\smateorodriguez\OneDrive - Deloitte (O365D)\Documents\personal-projects\egui_graphs"
+ cargo run -p egui_graphs --example demo
+ ```
+
+## Option 3: WSLg (Windows 11 Only)
+
+If you have Windows 11, WSLg should work automatically. Try:
+```bash
+wsl
+cd '/mnt/c/Users/smateorodriguez/OneDrive - Deloitte (O365D)/Documents/personal-projects/egui_graphs'
+cargo run -p egui_graphs --example demo
+```
+
+## Your New Color Picker Feature
+
+In the app (web or native):
+1. Press **Tab** or click **◀** (bottom-right) to open sidebar
+2. Go to **Style** section
+3. Scroll to **Custom Colors**
+4. Enable and pick colors for nodes and edges!
+
+## Current Status
+
+✅ Code compiled successfully
+✅ Web version running at http://127.0.0.1:8080/
+✅ Color picker feature implemented and working
+❌ Native execution blocked by missing display server in WSL
+
+**Recommendation:** Use the web version - it's fast, fully functional, and requires no additional setup!
diff --git a/crates/code-analyzer-web/.cargo/config.toml b/crates/code-analyzer-web/.cargo/config.toml
new file mode 100644
index 0000000..85c7482
--- /dev/null
+++ b/crates/code-analyzer-web/.cargo/config.toml
@@ -0,0 +1,5 @@
+[build]
+target = "wasm32-unknown-unknown"
+
+[target.wasm32-unknown-unknown]
+runner = 'wasm-bindgen-test-runner'
diff --git a/crates/code-analyzer-web/Cargo.toml b/crates/code-analyzer-web/Cargo.toml
new file mode 100644
index 0000000..2df332d
--- /dev/null
+++ b/crates/code-analyzer-web/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "code-analyzer-web"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+console_error_panic_hook = "0.1"
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+web-sys = { version = "0.3", features = ["Window", "Document", "HtmlCanvasElement"] }
+egui = "0.33"
+eframe = { version = "0.33", features = ["wgpu"] }
+egui_graphs = { path = "../egui_graphs" }
+petgraph = "0.8"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.3", features = ["wasm_js"] }
+
+[package.metadata.wasm-pack.profile.dev]
+wasm-opt = false
diff --git a/crates/code-analyzer-web/index.html b/crates/code-analyzer-web/index.html
new file mode 100644
index 0000000..2f1b645
--- /dev/null
+++ b/crates/code-analyzer-web/index.html
@@ -0,0 +1,116 @@
+
+
+
+
+
+ Code Analyzer - Class Relationship Visualizer
+
+
+
+
+
+
+
+
Loading Code Analyzer...
+
+
+
+
Error Loading Application
+
+
+
+
+
+
+
diff --git a/crates/code-analyzer-web/serve.sh b/crates/code-analyzer-web/serve.sh
new file mode 100644
index 0000000..ddc2eb6
--- /dev/null
+++ b/crates/code-analyzer-web/serve.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+source ~/.cargo/env
+export CARGO_TARGET_DIR=~/egui_graphs_target
+trunk serve --address 0.0.0.0 --port 8080
diff --git a/crates/code-analyzer-web/src/lib.rs b/crates/code-analyzer-web/src/lib.rs
new file mode 100644
index 0000000..99a3b8e
--- /dev/null
+++ b/crates/code-analyzer-web/src/lib.rs
@@ -0,0 +1,455 @@
+use eframe::wasm_bindgen::{self, prelude::*};
+
+#[wasm_bindgen]
+pub struct WebHandle {
+ runner: eframe::WebRunner,
+}
+
+#[wasm_bindgen]
+impl WebHandle {
+ #[wasm_bindgen(constructor)]
+ pub fn new() -> Self {
+ Self {
+ runner: eframe::WebRunner::new(),
+ }
+ }
+
+ #[wasm_bindgen]
+ pub async fn start(&self, canvas_id: &str) -> Result<(), wasm_bindgen::JsValue> {
+ self.runner
+ .start(
+ canvas_id,
+ eframe::WebOptions::default(),
+ Box::new(|cc| Ok(Box::new(code_analyzer::CodeAnalyzerApp::new(cc)))),
+ )
+ .await
+ }
+}
+
+mod code_analyzer {
+ use eframe::App;
+ use egui::{Color32, FontFamily, FontId, Pos2, Rect, Shape, Stroke, Vec2};
+ use egui_graphs::{
+ DisplayEdge, DisplayNode, DrawContext, EdgeProps, Graph, GraphView, Node, NodeProps,
+ SettingsInteraction, SettingsNavigation,
+ };
+ use petgraph::{stable_graph::{NodeIndex, StableGraph}, Directed};
+ use std::collections::HashMap;
+
+ #[derive(Clone, Debug)]
+ pub struct ClassInfo {
+ name: String,
+ methods: Vec,
+ fields: Vec,
+ }
+
+ #[derive(Clone, Debug)]
+ enum Relationship {
+ OneToOne,
+ OneToMany,
+ ManyToMany,
+ }
+
+ impl Relationship {
+ fn label(&self) -> &str {
+ match self {
+ Relationship::OneToOne => "1:1",
+ Relationship::OneToMany => "1:N",
+ Relationship::ManyToMany => "N:N",
+ }
+ }
+ }
+
+ #[derive(Clone, Debug)]
+ struct CodeNode {
+ pos: Pos2,
+ selected: bool,
+ dragged: bool,
+ hovered: bool,
+ class_name: String,
+ radius: f32,
+ }
+
+ impl From> for CodeNode {
+ fn from(node_props: NodeProps) -> Self {
+ Self {
+ pos: node_props.location(),
+ selected: node_props.selected,
+ dragged: node_props.dragged,
+ hovered: node_props.hovered,
+ class_name: node_props.payload.name.clone(),
+ radius: 30.0,
+ }
+ }
+ }
+
+ impl DisplayNode for CodeNode {
+ fn is_inside(&self, pos: Pos2) -> bool {
+ let dir = pos - self.pos;
+ dir.length() <= self.radius
+ }
+
+ fn closest_boundary_point(&self, dir: Vec2) -> Pos2 {
+ self.pos + dir.normalized() * self.radius
+ }
+
+ fn shapes(&mut self, ctx: &DrawContext) -> Vec {
+ let mut shapes = Vec::new();
+ let screen_pos = ctx.meta.canvas_to_screen_pos(self.pos);
+ let screen_radius = ctx.meta.canvas_to_screen_size(self.radius);
+
+ let color = if self.selected {
+ Color32::from_rgb(100, 200, 255)
+ } else if self.hovered {
+ Color32::from_rgb(150, 150, 200)
+ } else {
+ Color32::from_rgb(100, 150, 200)
+ };
+
+ let stroke = if self.selected {
+ Stroke::new(2.0, Color32::WHITE)
+ } else {
+ Stroke::new(1.0, Color32::GRAY)
+ };
+
+ shapes.push(
+ egui::epaint::CircleShape {
+ center: screen_pos,
+ radius: screen_radius,
+ fill: color,
+ stroke,
+ }
+ .into(),
+ );
+
+ let font_size = (screen_radius * 0.4).max(8.0).min(16.0);
+ let galley = ctx.ctx.fonts_mut(|f| {
+ f.layout_no_wrap(
+ self.class_name.clone(),
+ FontId::new(font_size, FontFamily::Proportional),
+ Color32::WHITE,
+ )
+ });
+
+ let text_pos = Pos2::new(
+ screen_pos.x - galley.size().x / 2.0,
+ screen_pos.y - galley.size().y / 2.0,
+ );
+
+ shapes.push(egui::epaint::TextShape::new(text_pos, galley, Color32::WHITE).into());
+ shapes
+ }
+
+ fn update(&mut self, state: &NodeProps) {
+ self.pos = state.location();
+ self.selected = state.selected;
+ self.dragged = state.dragged;
+ self.hovered = state.hovered;
+ self.class_name = state.payload.name.clone();
+ }
+ }
+
+ #[derive(Clone, Debug)]
+ struct CodeEdge {
+ order: usize,
+ selected: bool,
+ label: String,
+ }
+
+ impl From> for CodeEdge {
+ fn from(edge_props: EdgeProps) -> Self {
+ Self {
+ order: edge_props.order,
+ selected: edge_props.selected,
+ label: edge_props.payload.label().to_string(),
+ }
+ }
+ }
+
+ impl DisplayEdge
+ for CodeEdge
+ {
+ fn is_inside(
+ &self,
+ start: &Node,
+ end: &Node,
+ pos: Pos2,
+ ) -> bool {
+ let start_pos = start.location();
+ let end_pos = end.location();
+ let radius = 5.0;
+ let line_vec = end_pos - start_pos;
+ let point_vec = pos - start_pos;
+ let line_len = line_vec.length();
+ if line_len < 0.001 {
+ return false;
+ }
+ let proj = point_vec.dot(line_vec) / line_len;
+ if proj < 0.0 || proj > line_len {
+ return false;
+ }
+ let closest = start_pos + line_vec.normalized() * proj;
+ (pos - closest).length() <= radius
+ }
+
+ fn shapes(
+ &mut self,
+ start: &Node,
+ end: &Node,
+ ctx: &DrawContext,
+ ) -> Vec {
+ let start_pos = start.location();
+ let end_pos = end.location();
+
+ let dir = (end_pos - start_pos).normalized();
+ let start_boundary = start.display().closest_boundary_point(dir);
+ let end_boundary = end.display().closest_boundary_point(-dir);
+ let mut shapes = Vec::new();
+ let screen_start = ctx.meta.canvas_to_screen_pos(start_boundary);
+ let screen_end = ctx.meta.canvas_to_screen_pos(end_boundary);
+
+ let color = if self.selected {
+ Color32::from_rgb(255, 200, 100)
+ } else {
+ Color32::GRAY
+ };
+ let stroke = Stroke::new(2.0, color);
+
+ shapes.push(egui::epaint::Shape::line_segment([screen_start, screen_end], stroke));
+
+ let dir = (screen_end - screen_start).normalized();
+ let arrow_size = 10.0;
+ let perp = Vec2::new(-dir.y, dir.x);
+ let tip = screen_end - dir * arrow_size;
+ let left = tip + perp * arrow_size * 0.5;
+ let right = tip - perp * arrow_size * 0.5;
+
+ shapes.push(egui::epaint::Shape::convex_polygon(
+ vec![screen_end, left, right],
+ color,
+ Stroke::NONE,
+ ));
+
+ let midpoint = (screen_start + screen_end.to_vec2()) * 0.5;
+ let galley = ctx.ctx.fonts_mut(|f| {
+ f.layout_no_wrap(
+ self.label.clone(),
+ FontId::new(12.0, FontFamily::Proportional),
+ color,
+ )
+ });
+
+ let label_pos = Pos2::new(
+ midpoint.x - galley.size().x / 2.0,
+ midpoint.y - galley.size().y / 2.0 - 10.0,
+ );
+
+ let label_rect = Rect::from_min_size(label_pos, galley.size() + Vec2::new(4.0, 2.0));
+ shapes.push(egui::epaint::Shape::rect_filled(
+ label_rect,
+ 2.0,
+ Color32::from_black_alpha(200),
+ ));
+
+ shapes.push(
+ egui::epaint::TextShape::new(label_pos + Vec2::new(2.0, 1.0), galley, Color32::WHITE).into(),
+ );
+
+ shapes
+ }
+
+ fn update(&mut self, state: &EdgeProps) {
+ self.order = state.order;
+ self.selected = state.selected;
+ self.label = state.payload.label().to_string();
+ }
+ }
+
+ pub struct CodeAnalyzerApp {
+ graph: Graph,
+ class_details: HashMap, ClassInfo>,
+ hover_window_size: f32,
+ hovered_node: Option>,
+ }
+
+ impl CodeAnalyzerApp {
+ pub fn new(_cc: &eframe::CreationContext) -> Self {
+ let mut pg = StableGraph::::new();
+ let mut class_details = HashMap::new();
+
+ let user = pg.add_node(ClassInfo {
+ name: "User".to_string(),
+ methods: vec![
+ "login()".to_string(),
+ "logout()".to_string(),
+ "updateProfile()".to_string(),
+ ],
+ fields: vec![
+ "id: int".to_string(),
+ "username: string".to_string(),
+ "email: string".to_string(),
+ ],
+ });
+
+ let order = pg.add_node(ClassInfo {
+ name: "Order".to_string(),
+ methods: vec![
+ "calculate()".to_string(),
+ "submit()".to_string(),
+ "cancel()".to_string(),
+ ],
+ fields: vec![
+ "id: int".to_string(),
+ "total: float".to_string(),
+ "status: string".to_string(),
+ ],
+ });
+
+ let product = pg.add_node(ClassInfo {
+ name: "Product".to_string(),
+ methods: vec!["getPrice()".to_string(), "updateStock()".to_string()],
+ fields: vec![
+ "id: int".to_string(),
+ "name: string".to_string(),
+ "price: float".to_string(),
+ ],
+ });
+
+ let payment = pg.add_node(ClassInfo {
+ name: "Payment".to_string(),
+ methods: vec!["process()".to_string(), "refund()".to_string()],
+ fields: vec![
+ "id: int".to_string(),
+ "amount: float".to_string(),
+ "method: string".to_string(),
+ ],
+ });
+
+ for idx in pg.node_indices() {
+ if let Some(node) = pg.node_weight(idx) {
+ class_details.insert(idx, node.clone());
+ }
+ }
+
+ pg.add_edge(user, order, Relationship::OneToMany);
+ pg.add_edge(order, product, Relationship::ManyToMany);
+ pg.add_edge(order, payment, Relationship::OneToOne);
+ pg.add_edge(user, payment, Relationship::OneToMany);
+
+ let mut graph = Graph::::from(&pg);
+
+ let positions = vec![
+ Pos2::new(0.0, 100.0),
+ Pos2::new(200.0, 0.0),
+ Pos2::new(200.0, 200.0),
+ Pos2::new(400.0, 100.0),
+ ];
+
+ for (idx, pos) in pg.node_indices().zip(positions.iter()) {
+ if let Some(node) = graph.node_mut(idx) {
+ node.set_location(*pos);
+ }
+ }
+
+ Self {
+ graph,
+ class_details,
+ hover_window_size: 0.0625,
+ hovered_node: None,
+ }
+ }
+
+ fn draw_hover_popup(&self, ui: &mut egui::Ui, node_idx: NodeIndex) {
+ if let Some(class_info) = self.class_details.get(&node_idx) {
+ let screen_size = ui.ctx().content_rect().size();
+ let popup_size = Vec2::new(
+ screen_size.x * self.hover_window_size,
+ screen_size.y * self.hover_window_size,
+ );
+
+ egui::Window::new(&class_info.name)
+ .fixed_size(popup_size)
+ .collapsible(false)
+ .show(ui.ctx(), |ui| {
+ egui::ScrollArea::vertical().show(ui, |ui| {
+ ui.heading("Fields:");
+ for field in &class_info.fields {
+ ui.label(format!(" • {}", field));
+ }
+ ui.add_space(8.0);
+ ui.heading("Methods:");
+ for method in &class_info.methods {
+ ui.label(format!(" • {}", method));
+ }
+ });
+ });
+ }
+ }
+ }
+
+ impl App for CodeAnalyzerApp {
+ fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+ egui::SidePanel::right("settings").show(ctx, |ui| {
+ ui.heading("Code Analyzer Settings");
+ ui.separator();
+
+ ui.label("Popup Window Size:");
+ let mut size_percent = (self.hover_window_size * 100.0) as i32;
+ if ui
+ .add(egui::Slider::new(&mut size_percent, 5..=50).suffix("%"))
+ .changed()
+ {
+ self.hover_window_size = size_percent as f32 / 100.0;
+ }
+
+ ui.add_space(10.0);
+ ui.label("Legend:");
+ ui.label("🔵 Hover over nodes to see details");
+ ui.label("1:1 = One-to-One");
+ ui.label("1:N = One-to-Many");
+ ui.label("N:N = Many-to-Many");
+
+ ui.add_space(10.0);
+ ui.heading("Classes:");
+ for (idx, info) in &self.class_details {
+ if ui.button(&info.name).clicked() {
+ if let Some(node) = self.graph.node_mut(*idx) {
+ node.set_selected(true);
+ }
+ }
+ }
+ });
+
+ egui::CentralPanel::default().show(ctx, |ui| {
+ let settings_interaction = SettingsInteraction::new()
+ .with_dragging_enabled(true)
+ .with_hover_enabled(true);
+
+ let settings_navigation = SettingsNavigation::new()
+ .with_zoom_and_pan_enabled(true)
+ .with_fit_to_screen_enabled(false);
+
+ ui.add(
+ &mut GraphView::<_, _, _, _, CodeNode, CodeEdge>::new(&mut self.graph)
+ .with_interactions(&settings_interaction)
+ .with_navigations(&settings_navigation),
+ );
+
+ let mut new_hovered = None;
+ for idx in self.graph.g().node_indices() {
+ if let Some(node) = self.graph.node(idx) {
+ if node.hovered() {
+ new_hovered = Some(idx);
+ break;
+ }
+ }
+ }
+ self.hovered_node = new_hovered;
+
+ if let Some(node_idx) = self.hovered_node {
+ self.draw_hover_popup(ui, node_idx);
+ }
+ });
+ }
+ }
+}
diff --git a/crates/demo-core/src/lib.rs b/crates/demo-core/src/lib.rs
index 3b34d21..8bed2df 100644
--- a/crates/demo-core/src/lib.rs
+++ b/crates/demo-core/src/lib.rs
@@ -178,10 +178,7 @@ impl DemoApp {
settings_graph,
settings_interaction: settings::SettingsInteraction::default(),
settings_navigation: settings::SettingsNavigation::default(),
- settings_style: settings::SettingsStyle {
- labels_always: false,
- edge_deemphasis: true,
- },
+ settings_style: settings::SettingsStyle::default(),
metrics: MetricsRecorder::new(),
// Start with side panel hidden by default
show_sidebar: false,
@@ -435,10 +432,7 @@ impl DemoApp {
self.settings_graph = settings::SettingsGraph::default();
self.settings_interaction = settings::SettingsInteraction::default();
self.settings_navigation = settings::SettingsNavigation::default();
- self.settings_style = settings::SettingsStyle {
- labels_always: false,
- edge_deemphasis: true,
- };
+ self.settings_style = settings::SettingsStyle::default();
self.show_debug_overlay = true;
self.show_keybindings_overlay = false;
let mut g = generate_random_graph(
@@ -943,6 +937,98 @@ impl DemoApp {
ui.checkbox(&mut self.settings_style.edge_deemphasis, "edge_deemphasis");
info_icon(ui, "Dim non-selected edges to highlight current selection.");
});
+
+ ui.add_space(4.0);
+ ui.separator();
+ ui.label("Custom Colors");
+
+ // Node color controls
+ ui.horizontal(|ui| {
+ let mut use_node_color = self.settings_style.custom_node_color.is_some();
+ if ui.checkbox(&mut use_node_color, "Custom node color").changed() {
+ self.settings_style.custom_node_color = if use_node_color {
+ Some(Color32::from_rgb(100, 150, 250))
+ } else {
+ None
+ };
+ }
+ if let Some(ref mut color) = self.settings_style.custom_node_color {
+ ui.color_edit_button_srgba(color);
+ }
+ info_icon(ui, "Set a custom color for all nodes. Overrides theme defaults.");
+ });
+
+ // Node hex input
+ if self.settings_style.custom_node_color.is_some() {
+ ui.horizontal(|ui| {
+ ui.label("Hex:");
+ let current_hex = if let Some(c) = self.settings_style.custom_node_color {
+ format!("{:02X}{:02X}{:02X}", c.r(), c.g(), c.b())
+ } else {
+ String::new()
+ };
+ let mut hex_input = current_hex.clone();
+ let resp = ui.add(
+ egui::TextEdit::singleline(&mut hex_input)
+ .desired_width(70.0)
+ .char_limit(6)
+ );
+ if resp.has_focus() {
+ self.typing_in_input = true;
+ }
+ if resp.lost_focus() && hex_input != current_hex {
+ if let Ok(rgb) = parse_hex_color(&hex_input) {
+ self.settings_style.custom_node_color = Some(Color32::from_rgb(rgb.0, rgb.1, rgb.2));
+ }
+ }
+ ui.small_button("ℹ").on_hover_text("Enter 6-digit hex color code (e.g., FF5733)");
+ });
+ }
+
+ ui.add_space(2.0);
+
+ // Edge color controls
+ ui.horizontal(|ui| {
+ let mut use_edge_color = self.settings_style.custom_edge_color.is_some();
+ if ui.checkbox(&mut use_edge_color, "Custom edge color").changed() {
+ self.settings_style.custom_edge_color = if use_edge_color {
+ Some(Color32::from_rgb(150, 150, 150))
+ } else {
+ None
+ };
+ }
+ if let Some(ref mut color) = self.settings_style.custom_edge_color {
+ ui.color_edit_button_srgba(color);
+ }
+ info_icon(ui, "Set a custom color for all edges. Overrides theme defaults.");
+ });
+
+ // Edge hex input
+ if self.settings_style.custom_edge_color.is_some() {
+ ui.horizontal(|ui| {
+ ui.label("Hex:");
+ let current_hex = if let Some(c) = self.settings_style.custom_edge_color {
+ format!("{:02X}{:02X}{:02X}", c.r(), c.g(), c.b())
+ } else {
+ String::new()
+ };
+ let mut hex_input = current_hex.clone();
+ let resp = ui.add(
+ egui::TextEdit::singleline(&mut hex_input)
+ .desired_width(70.0)
+ .char_limit(6)
+ );
+ if resp.has_focus() {
+ self.typing_in_input = true;
+ }
+ if resp.lost_focus() && hex_input != current_hex {
+ if let Ok(rgb) = parse_hex_color(&hex_input) {
+ self.settings_style.custom_edge_color = Some(Color32::from_rgb(rgb.0, rgb.1, rgb.2));
+ }
+ }
+ ui.small_button("ℹ").on_hover_text("Enter 6-digit hex color code (e.g., 969696)");
+ });
+ }
});
}
@@ -1325,20 +1411,49 @@ impl App for DemoApp {
.with_fit_to_screen_enabled(self.settings_navigation.fit_to_screen_enabled)
.with_zoom_speed(self.settings_navigation.zoom_speed)
.with_fit_to_screen_padding(self.settings_navigation.fit_to_screen_padding);
+ // Apply custom node colors by setting them directly on the graph
+ if let Some(node_color) = self.settings_style.custom_node_color {
+ match &mut self.g {
+ DemoGraph::Directed(g) => {
+ let indices: Vec<_> = g.g().node_indices().collect();
+ for idx in indices {
+ if let Some(node) = g.g_mut().node_weight_mut(idx) {
+ node.set_color(node_color);
+ }
+ }
+ }
+ DemoGraph::Undirected(g) => {
+ let indices: Vec<_> = g.g().node_indices().collect();
+ for idx in indices {
+ if let Some(node) = g.g_mut().node_weight_mut(idx) {
+ node.set_color(node_color);
+ }
+ }
+ }
+ }
+ }
+
let mut style_builder = egui_graphs::SettingsStyle::new()
.with_labels_always(self.settings_style.labels_always);
- if self.settings_style.edge_deemphasis {
- style_builder =
- style_builder.with_edge_stroke_hook(|selected, _order, stroke, _style| {
- let mut s = stroke;
- if !selected {
- let c = s.color;
+
+ // Apply edge styling with optional custom color and deemphasis
+ let edge_custom_color = self.settings_style.custom_edge_color;
+ let edge_deemphasis = self.settings_style.edge_deemphasis;
+ if edge_custom_color.is_some() || edge_deemphasis {
+ style_builder = style_builder.with_edge_stroke_hook(
+ move |selected, _order, mut stroke, _style| {
+ if let Some(custom_color) = edge_custom_color {
+ stroke.color = custom_color;
+ }
+ if edge_deemphasis && !selected {
+ let c = stroke.color;
let new_a = (f32::from(c.a()) * 0.5) as u8;
- s.color =
+ stroke.color =
egui::Color32::from_rgba_unmultiplied(c.r(), c.g(), c.b(), new_a);
}
- s
- });
+ stroke
+ },
+ );
}
let settings_style = &style_builder;
@@ -1980,6 +2095,17 @@ fn draw_drop_overlay(ui: &mut egui::Ui, rect: Rect) {
);
}
+fn parse_hex_color(hex: &str) -> Result<(u8, u8, u8), ()> {
+ let hex = hex.trim().trim_start_matches('#');
+ if hex.len() != 6 {
+ return Err(());
+ }
+ let r = u8::from_str_radix(&hex[0..2], 16).map_err(|_| ())?;
+ let g = u8::from_str_radix(&hex[2..4], 16).map_err(|_| ())?;
+ let b = u8::from_str_radix(&hex[4..6], 16).map_err(|_| ())?;
+ Ok((r, g, b))
+}
+
// --- Web-only helpers for URL hash params and bundled example lookup ---
#[cfg(target_arch = "wasm32")]
pub(crate) fn web_hash_get_param(key: &str) -> Option {
diff --git a/crates/demo-core/src/settings.rs b/crates/demo-core/src/settings.rs
index 7b6456a..ec83485 100644
--- a/crates/demo-core/src/settings.rs
+++ b/crates/demo-core/src/settings.rs
@@ -28,10 +28,22 @@ impl Default for SettingsInteraction {
}
// Visual style toggles specific to the demo
-#[derive(Default)]
pub struct SettingsStyle {
pub labels_always: bool,
pub edge_deemphasis: bool,
+ pub custom_node_color: Option,
+ pub custom_edge_color: Option,
+}
+
+impl Default for SettingsStyle {
+ fn default() -> Self {
+ Self {
+ labels_always: false,
+ edge_deemphasis: true,
+ custom_node_color: None,
+ custom_edge_color: None,
+ }
+ }
}
// Navigation & viewport parameters
diff --git a/crates/egui_graphs/examples/code_analyzer.rs b/crates/egui_graphs/examples/code_analyzer.rs
new file mode 100644
index 0000000..98ef5d8
--- /dev/null
+++ b/crates/egui_graphs/examples/code_analyzer.rs
@@ -0,0 +1,484 @@
+use eframe::{run_native, App, NativeOptions};
+use egui::{
+ Color32, FontFamily, FontId, Pos2, Rect, Shape, Stroke, Vec2,
+};
+use egui_graphs::{
+ DisplayEdge, DisplayNode, DrawContext, EdgeProps, Graph, GraphView, Node, NodeProps, SettingsInteraction,
+ SettingsNavigation,
+};
+use petgraph::{
+ stable_graph::{NodeIndex, StableGraph},
+ Directed,
+};
+use std::collections::HashMap;
+
+// Data structures for code entities
+#[derive(Clone, Debug)]
+struct ClassInfo {
+ name: String,
+ methods: Vec,
+ fields: Vec,
+}
+
+#[derive(Clone, Debug)]
+enum Relationship {
+ OneToOne,
+ OneToMany,
+ ManyToMany,
+}
+
+impl Relationship {
+ fn label(&self) -> &str {
+ match self {
+ Relationship::OneToOne => "1:1",
+ Relationship::OneToMany => "1:N",
+ Relationship::ManyToMany => "N:N",
+ }
+ }
+}
+
+// Custom node display with class name
+#[derive(Clone, Debug)]
+struct CodeNode {
+ pos: Pos2,
+ selected: bool,
+ dragged: bool,
+ hovered: bool,
+ class_name: String,
+ radius: f32,
+}
+
+impl From> for CodeNode {
+ fn from(node_props: NodeProps) -> Self {
+ Self {
+ pos: node_props.location(),
+ selected: node_props.selected,
+ dragged: node_props.dragged,
+ hovered: node_props.hovered,
+ class_name: node_props.payload.name.clone(),
+ radius: 30.0,
+ }
+ }
+}
+
+impl DisplayNode for CodeNode {
+ fn is_inside(&self, pos: Pos2) -> bool {
+ let dir = pos - self.pos;
+ dir.length() <= self.radius
+ }
+
+ fn closest_boundary_point(&self, dir: Vec2) -> Pos2 {
+ self.pos + dir.normalized() * self.radius
+ }
+
+ fn shapes(&mut self, ctx: &DrawContext) -> Vec {
+ let mut shapes = Vec::new();
+ let screen_pos = ctx.meta.canvas_to_screen_pos(self.pos);
+ let screen_radius = ctx.meta.canvas_to_screen_size(self.radius);
+
+ // Node circle
+ let color = if self.selected {
+ Color32::from_rgb(100, 200, 255)
+ } else if self.hovered {
+ Color32::from_rgb(150, 150, 200)
+ } else {
+ Color32::from_rgb(100, 150, 200)
+ };
+
+ let stroke = if self.selected {
+ Stroke::new(2.0, Color32::WHITE)
+ } else {
+ Stroke::new(1.0, Color32::GRAY)
+ };
+
+ shapes.push(
+ egui::epaint::CircleShape {
+ center: screen_pos,
+ radius: screen_radius,
+ fill: color,
+ stroke,
+ }
+ .into(),
+ );
+
+ // Class name label inside the node
+ let font_size = (screen_radius * 0.4).max(8.0).min(16.0);
+ let galley = ctx.ctx.fonts_mut(|f| {
+ f.layout_no_wrap(
+ self.class_name.clone(),
+ FontId::new(font_size, FontFamily::Proportional),
+ Color32::WHITE,
+ )
+ });
+
+ let text_pos = Pos2::new(
+ screen_pos.x - galley.size().x / 2.0,
+ screen_pos.y - galley.size().y / 2.0,
+ );
+
+ shapes.push(
+ egui::epaint::TextShape::new(text_pos, galley, Color32::WHITE).into(),
+ );
+
+ shapes
+ }
+
+ fn update(&mut self, state: &NodeProps) {
+ self.pos = state.location();
+ self.selected = state.selected;
+ self.dragged = state.dragged;
+ self.hovered = state.hovered;
+ self.class_name = state.payload.name.clone();
+ }
+}
+
+// Custom edge display with relationship labels
+#[derive(Clone, Debug)]
+struct CodeEdge {
+ order: usize,
+ selected: bool,
+ label: String,
+}
+
+impl From> for CodeEdge {
+ fn from(edge_props: EdgeProps) -> Self {
+ Self {
+ order: edge_props.order,
+ selected: edge_props.selected,
+ label: edge_props.payload.label().to_string(),
+ }
+ }
+}
+
+impl DisplayEdge for CodeEdge {
+ fn is_inside(
+ &self,
+ start: &Node,
+ end: &Node,
+ pos: Pos2,
+ ) -> bool {
+ let start_pos = start.location();
+ let end_pos = end.location();
+ let radius = 5.0;
+ let line_vec = end_pos - start_pos;
+ let point_vec = pos - start_pos;
+ let line_len = line_vec.length();
+ if line_len < 0.001 {
+ return false;
+ }
+ let proj = point_vec.dot(line_vec) / line_len;
+ if proj < 0.0 || proj > line_len {
+ return false;
+ }
+ let closest = start_pos + line_vec.normalized() * proj;
+ (pos - closest).length() <= radius
+ }
+
+ fn shapes(
+ &mut self,
+ start: &Node,
+ end: &Node,
+ ctx: &DrawContext,
+ ) -> Vec {
+ let start_pos = start.location();
+ let end_pos = end.location();
+
+ let dir = (end_pos - start_pos).normalized();
+ let start_boundary = start.display().closest_boundary_point(dir);
+ let end_boundary = end.display().closest_boundary_point(-dir);
+ let mut shapes = Vec::new();
+ let screen_start = ctx.meta.canvas_to_screen_pos(start_boundary);
+ let screen_end = ctx.meta.canvas_to_screen_pos(end_boundary);
+
+ // Draw arrow line
+ let color = if self.selected {
+ Color32::from_rgb(255, 200, 100)
+ } else {
+ Color32::GRAY
+ };
+ let stroke = Stroke::new(2.0, color);
+
+ shapes.push(
+ egui::epaint::Shape::line_segment([screen_start, screen_end], stroke),
+ );
+
+ // Draw arrowhead
+ let dir = (screen_end - screen_start).normalized();
+ let arrow_size = 10.0;
+ let perp = Vec2::new(-dir.y, dir.x);
+ let tip = screen_end - dir * arrow_size;
+ let left = tip + perp * arrow_size * 0.5;
+ let right = tip - perp * arrow_size * 0.5;
+
+ shapes.push(egui::epaint::Shape::convex_polygon(
+ vec![screen_end, left, right],
+ color,
+ Stroke::NONE,
+ ));
+
+ // Draw relationship label at midpoint
+ let midpoint = (screen_start + screen_end.to_vec2()) * 0.5;
+ let galley = ctx.ctx.fonts_mut(|f| {
+ f.layout_no_wrap(
+ self.label.clone(),
+ FontId::new(12.0, FontFamily::Proportional),
+ color,
+ )
+ });
+
+ let label_pos = Pos2::new(
+ midpoint.x - galley.size().x / 2.0,
+ midpoint.y - galley.size().y / 2.0 - 10.0,
+ );
+
+ // Background for label
+ let label_rect = Rect::from_min_size(
+ label_pos,
+ galley.size() + Vec2::new(4.0, 2.0),
+ );
+ shapes.push(egui::epaint::Shape::rect_filled(
+ label_rect,
+ 2.0,
+ Color32::from_black_alpha(200),
+ ));
+
+ shapes.push(
+ egui::epaint::TextShape::new(
+ label_pos + Vec2::new(2.0, 1.0),
+ galley,
+ Color32::WHITE,
+ )
+ .into(),
+ );
+
+ shapes
+ }
+
+ fn update(&mut self, state: &EdgeProps) {
+ self.order = state.order;
+ self.selected = state.selected;
+ self.label = state.payload.label().to_string();
+ }
+}
+
+// Main application
+struct CodeAnalyzerApp {
+ graph: Graph,
+ class_details: HashMap, ClassInfo>,
+ hover_window_size: f32,
+ hovered_node: Option>,
+}
+
+impl CodeAnalyzerApp {
+ fn new(_cc: &eframe::CreationContext) -> Self {
+ // Create sample class structure
+ let mut pg = StableGraph::::new();
+ let mut class_details = HashMap::new();
+
+ // Add classes
+ let user = pg.add_node(ClassInfo {
+ name: "User".to_string(),
+ methods: vec![
+ "login()".to_string(),
+ "logout()".to_string(),
+ "updateProfile()".to_string(),
+ ],
+ fields: vec![
+ "id: int".to_string(),
+ "username: string".to_string(),
+ "email: string".to_string(),
+ ],
+ });
+
+ let order = pg.add_node(ClassInfo {
+ name: "Order".to_string(),
+ methods: vec![
+ "calculate()".to_string(),
+ "submit()".to_string(),
+ "cancel()".to_string(),
+ ],
+ fields: vec![
+ "id: int".to_string(),
+ "total: float".to_string(),
+ "status: string".to_string(),
+ ],
+ });
+
+ let product = pg.add_node(ClassInfo {
+ name: "Product".to_string(),
+ methods: vec![
+ "getPrice()".to_string(),
+ "updateStock()".to_string(),
+ ],
+ fields: vec![
+ "id: int".to_string(),
+ "name: string".to_string(),
+ "price: float".to_string(),
+ ],
+ });
+
+ let payment = pg.add_node(ClassInfo {
+ name: "Payment".to_string(),
+ methods: vec![
+ "process()".to_string(),
+ "refund()".to_string(),
+ ],
+ fields: vec![
+ "id: int".to_string(),
+ "amount: float".to_string(),
+ "method: string".to_string(),
+ ],
+ });
+
+ // Store class details
+ for idx in pg.node_indices() {
+ if let Some(node) = pg.node_weight(idx) {
+ class_details.insert(idx, node.clone());
+ }
+ }
+
+ // Add relationships
+ pg.add_edge(user, order, Relationship::OneToMany);
+ pg.add_edge(order, product, Relationship::ManyToMany);
+ pg.add_edge(order, payment, Relationship::OneToOne);
+ pg.add_edge(user, payment, Relationship::OneToMany);
+
+ let mut graph = Graph::::from(&pg);
+
+ // Position nodes in a layout
+ let positions = vec![
+ Pos2::new(0.0, 100.0),
+ Pos2::new(200.0, 0.0),
+ Pos2::new(200.0, 200.0),
+ Pos2::new(400.0, 100.0),
+ ];
+
+ for (idx, pos) in pg.node_indices().zip(positions.iter()) {
+ if let Some(node) = graph.node_mut(idx) {
+ node.set_location(*pos);
+ }
+ }
+
+ Self {
+ graph,
+ class_details,
+ hover_window_size: 0.0625, // 1/16 of screen
+ hovered_node: None,
+ }
+ }
+
+ fn draw_hover_popup(&self, ui: &mut egui::Ui, node_idx: NodeIndex) {
+ if let Some(class_info) = self.class_details.get(&node_idx) {
+ let screen_size = ui.ctx().content_rect().size();
+ let popup_size = Vec2::new(
+ screen_size.x * self.hover_window_size,
+ screen_size.y * self.hover_window_size,
+ );
+
+ egui::Window::new(&class_info.name)
+ .fixed_size(popup_size)
+ .collapsible(false)
+ .show(ui.ctx(), |ui| {
+ egui::ScrollArea::vertical().show(ui, |ui| {
+ ui.heading("Fields:");
+ for field in &class_info.fields {
+ ui.label(format!(" • {}", field));
+ }
+ ui.add_space(8.0);
+ ui.heading("Methods:");
+ for method in &class_info.methods {
+ ui.label(format!(" • {}", method));
+ }
+ });
+ });
+ }
+ }
+}
+
+impl App for CodeAnalyzerApp {
+ fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+ // Side panel for settings
+ egui::SidePanel::right("settings").show(ctx, |ui| {
+ ui.heading("Code Analyzer Settings");
+ ui.separator();
+
+ ui.label("Popup Window Size:");
+ let mut size_percent = (self.hover_window_size * 100.0) as i32;
+ if ui
+ .add(egui::Slider::new(&mut size_percent, 5..=50).suffix("%"))
+ .changed()
+ {
+ self.hover_window_size = size_percent as f32 / 100.0;
+ }
+
+ ui.add_space(10.0);
+ ui.label("Legend:");
+ ui.label("🔵 Hover over nodes to see details");
+ ui.label("1:1 = One-to-One");
+ ui.label("1:N = One-to-Many");
+ ui.label("N:N = Many-to-Many");
+
+ ui.add_space(10.0);
+ ui.heading("Classes:");
+ for (idx, info) in &self.class_details {
+ if ui.button(&info.name).clicked() {
+ if let Some(node) = self.graph.node_mut(*idx) {
+ node.set_selected(true);
+ }
+ }
+ }
+ });
+
+ // Main graph view
+ egui::CentralPanel::default().show(ctx, |ui| {
+ let settings_interaction = SettingsInteraction::new()
+ .with_dragging_enabled(true)
+ .with_hover_enabled(true);
+
+ let settings_navigation = SettingsNavigation::new()
+ .with_zoom_and_pan_enabled(true)
+ .with_fit_to_screen_enabled(false);
+
+ ui.add(
+ &mut GraphView::<_, _, _, _, CodeNode, CodeEdge>::new(&mut self.graph)
+ .with_interactions(&settings_interaction)
+ .with_navigations(&settings_navigation),
+ );
+
+ // Check for hovered node
+ let mut new_hovered = None;
+ for idx in self.graph.g().node_indices() {
+ if let Some(node) = self.graph.node(idx) {
+ if node.hovered() {
+ new_hovered = Some(idx);
+ break;
+ }
+ }
+ }
+ self.hovered_node = new_hovered;
+
+ // Draw popup for hovered node
+ if let Some(node_idx) = self.hovered_node {
+ self.draw_hover_popup(ui, node_idx);
+ }
+ });
+ }
+}
+
+fn main() {
+ let options = NativeOptions {
+ viewport: egui::ViewportBuilder::default()
+ .with_inner_size([1200.0, 800.0])
+ .with_resizable(true)
+ .with_decorations(true)
+ .with_transparent(false),
+ ..Default::default()
+ };
+
+ run_native(
+ "Code Analyzer - Class Relationships",
+ options,
+ Box::new(|cc| Ok(Box::new(CodeAnalyzerApp::new(cc)))),
+ )
+ .unwrap();
+}
From ca2bed5b85e9e864931bdf77c6052cddd2a7c99e Mon Sep 17 00:00:00 2001
From: Sam-coder183 <74673264+Sam-coder183@users.noreply.github.com>
Date: Sat, 22 Nov 2025 20:47:54 +0100
Subject: [PATCH 02/21] hotfix1
---
.../code-analyzer-web-7f0a84c7ccb889a2.js | 1908 +++++++++++++++++
...code-analyzer-web-7f0a84c7ccb889a2_bg.wasm | Bin 0 -> 9043274 bytes
crates/code-analyzer-web/dist/index.html | 252 +++
crates/code-analyzer-web/index.html | 31 +-
crates/code-analyzer-web/src/lib.rs | 45 +-
5 files changed, 2209 insertions(+), 27 deletions(-)
create mode 100644 crates/code-analyzer-web/dist/code-analyzer-web-7f0a84c7ccb889a2.js
create mode 100644 crates/code-analyzer-web/dist/code-analyzer-web-7f0a84c7ccb889a2_bg.wasm
create mode 100644 crates/code-analyzer-web/dist/index.html
diff --git a/crates/code-analyzer-web/dist/code-analyzer-web-7f0a84c7ccb889a2.js b/crates/code-analyzer-web/dist/code-analyzer-web-7f0a84c7ccb889a2.js
new file mode 100644
index 0000000..94c77ea
--- /dev/null
+++ b/crates/code-analyzer-web/dist/code-analyzer-web-7f0a84c7ccb889a2.js
@@ -0,0 +1,1908 @@
+let wasm;
+
+function isLikeNone(x) {
+ return x === undefined || x === null;
+}
+
+function debugString(val) {
+ // primitive types
+ const type = typeof val;
+ if (type == 'number' || type == 'boolean' || val == null) {
+ return `${val}`;
+ }
+ if (type == 'string') {
+ return `"${val}"`;
+ }
+ if (type == 'symbol') {
+ const description = val.description;
+ if (description == null) {
+ return 'Symbol';
+ } else {
+ return `Symbol(${description})`;
+ }
+ }
+ if (type == 'function') {
+ const name = val.name;
+ if (typeof name == 'string' && name.length > 0) {
+ return `Function(${name})`;
+ } else {
+ return 'Function';
+ }
+ }
+ // objects
+ if (Array.isArray(val)) {
+ const length = val.length;
+ let debug = '[';
+ if (length > 0) {
+ debug += debugString(val[0]);
+ }
+ for(let i = 1; i < length; i++) {
+ debug += ', ' + debugString(val[i]);
+ }
+ debug += ']';
+ return debug;
+ }
+ // Test for built-in
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+ let className;
+ if (builtInMatches && builtInMatches.length > 1) {
+ className = builtInMatches[1];
+ } else {
+ // Failed to match the standard '[object ClassName]'
+ return toString.call(val);
+ }
+ if (className == 'Object') {
+ // we're a user defined class or Object
+ // JSON.stringify avoids problems with cycles, and is generally much
+ // easier than looping through ownProperties of `val`.
+ try {
+ return 'Object(' + JSON.stringify(val) + ')';
+ } catch (_) {
+ return 'Object';
+ }
+ }
+ // errors
+ if (val instanceof Error) {
+ return `${val.name}: ${val.message}\n${val.stack}`;
+ }
+ // TODO we could test for more things here, like `Set`s and `Map`s.
+ return className;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+ }
+ return cachedUint8ArrayMemory0;
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+ cachedTextEncoder.encodeInto = function (arg, view) {
+ const buf = cachedTextEncoder.encode(arg);
+ view.set(buf);
+ return {
+ read: arg.length,
+ written: buf.length
+ };
+ }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+ if (realloc === undefined) {
+ const buf = cachedTextEncoder.encode(arg);
+ const ptr = malloc(buf.length, 1) >>> 0;
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+ WASM_VECTOR_LEN = buf.length;
+ return ptr;
+ }
+
+ let len = arg.length;
+ let ptr = malloc(len, 1) >>> 0;
+
+ const mem = getUint8ArrayMemory0();
+
+ let offset = 0;
+
+ for (; offset < len; offset++) {
+ const code = arg.charCodeAt(offset);
+ if (code > 0x7F) break;
+ mem[ptr + offset] = code;
+ }
+
+ if (offset !== len) {
+ if (offset !== 0) {
+ arg = arg.slice(offset);
+ }
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+ const ret = cachedTextEncoder.encodeInto(arg, view);
+
+ offset += ret.written;
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
+ }
+
+ WASM_VECTOR_LEN = offset;
+ return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+ }
+ return cachedDataViewMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+ numBytesDecoded += len;
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+ cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+ cachedTextDecoder.decode();
+ numBytesDecoded = len;
+ }
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return decodeText(ptr, len);
+}
+
+function addToExternrefTable0(obj) {
+ const idx = wasm.__externref_table_alloc();
+ wasm.__wbindgen_externrefs.set(idx, obj);
+ return idx;
+}
+
+function handleError(f, args) {
+ try {
+ return f.apply(this, args);
+ } catch (e) {
+ const idx = addToExternrefTable0(e);
+ wasm.__wbindgen_exn_store(idx);
+ }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+ ? { register: () => {}, unregister: () => {} }
+ : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+ const state = { a: arg0, b: arg1, cnt: 1, dtor };
+ const real = (...args) => {
+
+ // First up with a closure we increment the internal reference
+ // count. This ensures that the Rust closure environment won't
+ // be deallocated while we're invoking it.
+ state.cnt++;
+ const a = state.a;
+ state.a = 0;
+ try {
+ return f(a, state.b, ...args);
+ } finally {
+ state.a = a;
+ real._wbg_cb_unref();
+ }
+ };
+ real._wbg_cb_unref = () => {
+ if (--state.cnt === 0) {
+ state.dtor(state.a, state.b);
+ state.a = 0;
+ CLOSURE_DTORS.unregister(state);
+ }
+ };
+ CLOSURE_DTORS.register(real, state, state);
+ return real;
+}
+
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+ if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+ cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+ }
+ return cachedUint32ArrayMemory0;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+let cachedInt32ArrayMemory0 = null;
+
+function getInt32ArrayMemory0() {
+ if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
+ cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
+ }
+ return cachedInt32ArrayMemory0;
+}
+
+function getArrayI32FromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+let cachedUint16ArrayMemory0 = null;
+
+function getUint16ArrayMemory0() {
+ if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
+ cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+ }
+ return cachedUint16ArrayMemory0;
+}
+
+function getArrayU16FromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+
+let cachedFloat32ArrayMemory0 = null;
+
+function getFloat32ArrayMemory0() {
+ if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+ cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+ }
+ return cachedFloat32ArrayMemory0;
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+let cachedInt16ArrayMemory0 = null;
+
+function getInt16ArrayMemory0() {
+ if (cachedInt16ArrayMemory0 === null || cachedInt16ArrayMemory0.byteLength === 0) {
+ cachedInt16ArrayMemory0 = new Int16Array(wasm.memory.buffer);
+ }
+ return cachedInt16ArrayMemory0;
+}
+
+function getArrayI16FromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return getInt16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+
+let cachedInt8ArrayMemory0 = null;
+
+function getInt8ArrayMemory0() {
+ if (cachedInt8ArrayMemory0 === null || cachedInt8ArrayMemory0.byteLength === 0) {
+ cachedInt8ArrayMemory0 = new Int8Array(wasm.memory.buffer);
+ }
+ return cachedInt8ArrayMemory0;
+}
+
+function getArrayI8FromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return getInt8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+export function start() {
+ wasm.start();
+}
+
+function wasm_bindgen__convert__closures_____invoke__h8ae3b4a2c216dc58(arg0, arg1, arg2) {
+ wasm.wasm_bindgen__convert__closures_____invoke__h8ae3b4a2c216dc58(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h149fdb4773432f0b(arg0, arg1, arg2) {
+ wasm.wasm_bindgen__convert__closures_____invoke__h149fdb4773432f0b(arg0, arg1, arg2);
+}
+
+function takeFromExternrefTable0(idx) {
+ const value = wasm.__wbindgen_externrefs.get(idx);
+ wasm.__externref_table_dealloc(idx);
+ return value;
+}
+function wasm_bindgen__convert__closures_____invoke__haa4abc61e2c846b6(arg0, arg1) {
+ const ret = wasm.wasm_bindgen__convert__closures_____invoke__haa4abc61e2c846b6(arg0, arg1);
+ if (ret[1]) {
+ throw takeFromExternrefTable0(ret[0]);
+ }
+}
+
+function wasm_bindgen__convert__closures_____invoke__h2e9715ce298bdfd4(arg0, arg1, arg2) {
+ wasm.wasm_bindgen__convert__closures_____invoke__h2e9715ce298bdfd4(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__hbac06d5f8f19c42d(arg0, arg1) {
+ const ret = wasm.wasm_bindgen__convert__closures_____invoke__hbac06d5f8f19c42d(arg0, arg1);
+ return ret !== 0;
+}
+
+const __wbindgen_enum_ResizeObserverBoxOptions = ["border-box", "content-box", "device-pixel-content-box"];
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+async function __wbg_load(module, imports) {
+ if (typeof Response === 'function' && module instanceof Response) {
+ if (typeof WebAssembly.instantiateStreaming === 'function') {
+ try {
+ return await WebAssembly.instantiateStreaming(module, imports);
+
+ } catch (e) {
+ const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+ if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+ console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+ } else {
+ throw e;
+ }
+ }
+ }
+
+ const bytes = await module.arrayBuffer();
+ return await WebAssembly.instantiate(bytes, imports);
+
+ } else {
+ const instance = await WebAssembly.instantiate(module, imports);
+
+ if (instance instanceof WebAssembly.Instance) {
+ return { instance, module };
+
+ } else {
+ return instance;
+ }
+ }
+}
+
+function __wbg_get_imports() {
+ const imports = {};
+ imports.wbg = {};
+ imports.wbg.__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68 = function(arg0) {
+ const v = arg0;
+ const ret = typeof(v) === 'boolean' ? v : undefined;
+ return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+ };
+ imports.wbg.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {
+ const ret = debugString(arg1);
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg___wbindgen_in_bb933bd9e1b3bc0f = function(arg0, arg1) {
+ const ret = arg0 in arg1;
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {
+ const ret = typeof(arg0) === 'function';
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {
+ const ret = arg0 === undefined;
+ return ret;
+ };
+ imports.wbg.__wbg___wbindgen_number_get_a20bf9b85341449d = function(arg0, arg1) {
+ const obj = arg1;
+ const ret = typeof(obj) === 'number' ? obj : undefined;
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+ };
+ imports.wbg.__wbg___wbindgen_rethrow_ea38273dafc473e6 = function(arg0) {
+ throw arg0;
+ };
+ imports.wbg.__wbg___wbindgen_string_get_e4f06c90489ad01b = function(arg0, arg1) {
+ const obj = arg1;
+ const ret = typeof(obj) === 'string' ? obj : undefined;
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {
+ throw new Error(getStringFromWasm0(arg0, arg1));
+ };
+ imports.wbg.__wbg__wbg_cb_unref_2454a539ea5790d9 = function(arg0) {
+ arg0._wbg_cb_unref();
+ };
+ imports.wbg.__wbg_activeElement_acfd089919b80462 = function(arg0) {
+ const ret = arg0.activeElement;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_activeElement_c22f19bd2aa07d3e = function(arg0) {
+ const ret = arg0.activeElement;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_activeTexture_48c9bc28acaaa54d = function(arg0, arg1) {
+ arg0.activeTexture(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_activeTexture_f84308a5d2b7001d = function(arg0, arg1) {
+ arg0.activeTexture(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_addEventListener_534b9f715f44517f = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+ arg0.addEventListener(getStringFromWasm0(arg1, arg2), arg3, arg4);
+ }, arguments) };
+ imports.wbg.__wbg_altKey_1afb1a12d93938b0 = function(arg0) {
+ const ret = arg0.altKey;
+ return ret;
+ };
+ imports.wbg.__wbg_altKey_ab1e889cd83cf088 = function(arg0) {
+ const ret = arg0.altKey;
+ return ret;
+ };
+ imports.wbg.__wbg_appendChild_aec7a8a4bd6cac61 = function() { return handleError(function (arg0, arg1) {
+ const ret = arg0.appendChild(arg1);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_arrayBuffer_5930938a049abc90 = function(arg0) {
+ const ret = arg0.arrayBuffer();
+ return ret;
+ };
+ imports.wbg.__wbg_at_a848c0ce365c6832 = function(arg0, arg1) {
+ const ret = arg0.at(arg1);
+ return ret;
+ };
+ imports.wbg.__wbg_attachShader_28ab04bfd0eeb19d = function(arg0, arg1, arg2) {
+ arg0.attachShader(arg1, arg2);
+ };
+ imports.wbg.__wbg_attachShader_4729f6e4e28e3c47 = function(arg0, arg1, arg2) {
+ arg0.attachShader(arg1, arg2);
+ };
+ imports.wbg.__wbg_bindBuffer_3c6f3ecc1a210ca3 = function(arg0, arg1, arg2) {
+ arg0.bindBuffer(arg1 >>> 0, arg2);
+ };
+ imports.wbg.__wbg_bindBuffer_54099db8f6d4b751 = function(arg0, arg1, arg2) {
+ arg0.bindBuffer(arg1 >>> 0, arg2);
+ };
+ imports.wbg.__wbg_bindTexture_ada4abace31e0749 = function(arg0, arg1, arg2) {
+ arg0.bindTexture(arg1 >>> 0, arg2);
+ };
+ imports.wbg.__wbg_bindTexture_d9b13673706adf9e = function(arg0, arg1, arg2) {
+ arg0.bindTexture(arg1 >>> 0, arg2);
+ };
+ imports.wbg.__wbg_bindVertexArrayOES_86f8b49c99908d4a = function(arg0, arg1) {
+ arg0.bindVertexArrayOES(arg1);
+ };
+ imports.wbg.__wbg_bindVertexArray_c061c24c9d2fbfef = function(arg0, arg1) {
+ arg0.bindVertexArray(arg1);
+ };
+ imports.wbg.__wbg_blendEquationSeparate_30f938178b4bf4ea = function(arg0, arg1, arg2) {
+ arg0.blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
+ };
+ imports.wbg.__wbg_blendEquationSeparate_8fd8b8c2468c0d49 = function(arg0, arg1, arg2) {
+ arg0.blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
+ };
+ imports.wbg.__wbg_blendFuncSeparate_01e331a4feaf2532 = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
+ };
+ imports.wbg.__wbg_blendFuncSeparate_efd2b4ec166727db = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
+ };
+ imports.wbg.__wbg_blockSize_f20a7ec2c5bcce10 = function(arg0) {
+ const ret = arg0.blockSize;
+ return ret;
+ };
+ imports.wbg.__wbg_blur_8d22d76019f9d6a0 = function() { return handleError(function (arg0) {
+ arg0.blur();
+ }, arguments) };
+ imports.wbg.__wbg_body_8c26b54829a0c4cb = function(arg0) {
+ const ret = arg0.body;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_bottom_48779afa7b750239 = function(arg0) {
+ const ret = arg0.bottom;
+ return ret;
+ };
+ imports.wbg.__wbg_bufferData_121b54242e0dabb1 = function(arg0, arg1, arg2, arg3) {
+ arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
+ };
+ imports.wbg.__wbg_bufferData_6c7fa43be0e969d6 = function(arg0, arg1, arg2, arg3) {
+ arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
+ };
+ imports.wbg.__wbg_button_cd095d6d829d3270 = function(arg0) {
+ const ret = arg0.button;
+ return ret;
+ };
+ imports.wbg.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
+ const ret = arg0.call(arg1);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_cancelAnimationFrame_f6c090ea700b5a50 = function() { return handleError(function (arg0, arg1) {
+ arg0.cancelAnimationFrame(arg1);
+ }, arguments) };
+ imports.wbg.__wbg_cancel_5e195e393196a799 = function(arg0) {
+ arg0.cancel();
+ };
+ imports.wbg.__wbg_changedTouches_42c07e8d12d1bbcc = function(arg0) {
+ const ret = arg0.changedTouches;
+ return ret;
+ };
+ imports.wbg.__wbg_clearColor_95a9ab5565d42083 = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.clearColor(arg1, arg2, arg3, arg4);
+ };
+ imports.wbg.__wbg_clearColor_e7b3ddf4fdaaecaa = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.clearColor(arg1, arg2, arg3, arg4);
+ };
+ imports.wbg.__wbg_clearInterval_0675249bbe52da7b = function(arg0, arg1) {
+ arg0.clearInterval(arg1);
+ };
+ imports.wbg.__wbg_clear_21e859b27ff741c4 = function(arg0, arg1) {
+ arg0.clear(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_clear_bd1d14ac12f3d45d = function(arg0, arg1) {
+ arg0.clear(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_clientX_1166635f13c2a22e = function(arg0) {
+ const ret = arg0.clientX;
+ return ret;
+ };
+ imports.wbg.__wbg_clientX_97c1ab5b7abf71d4 = function(arg0) {
+ const ret = arg0.clientX;
+ return ret;
+ };
+ imports.wbg.__wbg_clientY_6b2560a0984b55af = function(arg0) {
+ const ret = arg0.clientY;
+ return ret;
+ };
+ imports.wbg.__wbg_clientY_d0eab302753c17d9 = function(arg0) {
+ const ret = arg0.clientY;
+ return ret;
+ };
+ imports.wbg.__wbg_clipboardData_1f4d4e422564e133 = function(arg0) {
+ const ret = arg0.clipboardData;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_clipboard_83c63b95503bfec1 = function(arg0) {
+ const ret = arg0.clipboard;
+ return ret;
+ };
+ imports.wbg.__wbg_colorMask_27f4ed2cabe913b5 = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.colorMask(arg1 !== 0, arg2 !== 0, arg3 !== 0, arg4 !== 0);
+ };
+ imports.wbg.__wbg_colorMask_ac1f3bfc9431295b = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.colorMask(arg1 !== 0, arg2 !== 0, arg3 !== 0, arg4 !== 0);
+ };
+ imports.wbg.__wbg_compileShader_8be7809a35b5b8d1 = function(arg0, arg1) {
+ arg0.compileShader(arg1);
+ };
+ imports.wbg.__wbg_compileShader_b6b9c3922553e2b5 = function(arg0, arg1) {
+ arg0.compileShader(arg1);
+ };
+ imports.wbg.__wbg_contentBoxSize_554560be57215ee6 = function(arg0) {
+ const ret = arg0.contentBoxSize;
+ return ret;
+ };
+ imports.wbg.__wbg_contentRect_26af16e75cc97c65 = function(arg0) {
+ const ret = arg0.contentRect;
+ return ret;
+ };
+ imports.wbg.__wbg_createBuffer_5d773097dcb49bc5 = function(arg0) {
+ const ret = arg0.createBuffer();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createBuffer_9ec61509720be784 = function(arg0) {
+ const ret = arg0.createBuffer();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createElement_964ab674a0176cd8 = function() { return handleError(function (arg0, arg1, arg2) {
+ const ret = arg0.createElement(getStringFromWasm0(arg1, arg2));
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_createProgram_3de15304f8ebbc28 = function(arg0) {
+ const ret = arg0.createProgram();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createProgram_76f1b3b1649a6a70 = function(arg0) {
+ const ret = arg0.createProgram();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createShader_800924f280388e4d = function(arg0, arg1) {
+ const ret = arg0.createShader(arg1 >>> 0);
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createShader_8956396370304fdd = function(arg0, arg1) {
+ const ret = arg0.createShader(arg1 >>> 0);
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createTask_9ac11a42c24ef284 = function() { return handleError(function (arg0, arg1) {
+ const ret = console.createTask(getStringFromWasm0(arg0, arg1));
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_createTexture_b4154609b3be9454 = function(arg0) {
+ const ret = arg0.createTexture();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createTexture_f088ddfa0b4394ed = function(arg0) {
+ const ret = arg0.createTexture();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createVertexArrayOES_72077a0d85a95427 = function(arg0) {
+ const ret = arg0.createVertexArrayOES();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_createVertexArray_0060b507a03b9521 = function(arg0) {
+ const ret = arg0.createVertexArray();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_ctrlKey_5621e1a6fd6decc2 = function(arg0) {
+ const ret = arg0.ctrlKey;
+ return ret;
+ };
+ imports.wbg.__wbg_ctrlKey_566441f821ad6b91 = function(arg0) {
+ const ret = arg0.ctrlKey;
+ return ret;
+ };
+ imports.wbg.__wbg_dataTransfer_ac196d77762b90f5 = function(arg0) {
+ const ret = arg0.dataTransfer;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_data_375e6b6c9e4e372b = function(arg0, arg1) {
+ const ret = arg1.data;
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_deleteBuffer_12e435724ee42b31 = function(arg0, arg1) {
+ arg0.deleteBuffer(arg1);
+ };
+ imports.wbg.__wbg_deleteBuffer_1d3ed354bfcc9cc1 = function(arg0, arg1) {
+ arg0.deleteBuffer(arg1);
+ };
+ imports.wbg.__wbg_deleteProgram_14d7e1bba4c2a048 = function(arg0, arg1) {
+ arg0.deleteProgram(arg1);
+ };
+ imports.wbg.__wbg_deleteProgram_57e178b9a4712e5d = function(arg0, arg1) {
+ arg0.deleteProgram(arg1);
+ };
+ imports.wbg.__wbg_deleteShader_8c57ca62bb68c92a = function(arg0, arg1) {
+ arg0.deleteShader(arg1);
+ };
+ imports.wbg.__wbg_deleteShader_fc28d3e4e0b5dce1 = function(arg0, arg1) {
+ arg0.deleteShader(arg1);
+ };
+ imports.wbg.__wbg_deleteTexture_52d70a9a7a6185f5 = function(arg0, arg1) {
+ arg0.deleteTexture(arg1);
+ };
+ imports.wbg.__wbg_deleteTexture_e8ccb15bc8feb76d = function(arg0, arg1) {
+ arg0.deleteTexture(arg1);
+ };
+ imports.wbg.__wbg_deltaMode_07ce5244f9725729 = function(arg0) {
+ const ret = arg0.deltaMode;
+ return ret;
+ };
+ imports.wbg.__wbg_deltaX_52dbec35cfc88ef2 = function(arg0) {
+ const ret = arg0.deltaX;
+ return ret;
+ };
+ imports.wbg.__wbg_deltaY_533a14decfb96f6b = function(arg0) {
+ const ret = arg0.deltaY;
+ return ret;
+ };
+ imports.wbg.__wbg_detachShader_739e7d9f35b46be1 = function(arg0, arg1, arg2) {
+ arg0.detachShader(arg1, arg2);
+ };
+ imports.wbg.__wbg_detachShader_8b95c9f94c9288ce = function(arg0, arg1, arg2) {
+ arg0.detachShader(arg1, arg2);
+ };
+ imports.wbg.__wbg_devicePixelContentBoxSize_36e338e852526803 = function(arg0) {
+ const ret = arg0.devicePixelContentBoxSize;
+ return ret;
+ };
+ imports.wbg.__wbg_devicePixelRatio_495c092455fdf6b1 = function(arg0) {
+ const ret = arg0.devicePixelRatio;
+ return ret;
+ };
+ imports.wbg.__wbg_disableVertexAttribArray_b05c9e7b1b3ecc2f = function(arg0, arg1) {
+ arg0.disableVertexAttribArray(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_disableVertexAttribArray_e9d52218e665768f = function(arg0, arg1) {
+ arg0.disableVertexAttribArray(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_disable_3c01320ea56d1bad = function(arg0, arg1) {
+ arg0.disable(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_disable_8a379385ec68f6aa = function(arg0, arg1) {
+ arg0.disable(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_disconnect_26bdefa21f6e8a2f = function(arg0) {
+ arg0.disconnect();
+ };
+ imports.wbg.__wbg_document_725ae06eb442a6db = function(arg0) {
+ const ret = arg0.document;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_drawElements_7c2a1a67924d993d = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.drawElements(arg1 >>> 0, arg2, arg3 >>> 0, arg4);
+ };
+ imports.wbg.__wbg_drawElements_8259eee7121b4791 = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.drawElements(arg1 >>> 0, arg2, arg3 >>> 0, arg4);
+ };
+ imports.wbg.__wbg_elementFromPoint_4dca36851eb6c5d2 = function(arg0, arg1, arg2) {
+ const ret = arg0.elementFromPoint(arg1, arg2);
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_elementFromPoint_a53d78ac95bcc438 = function(arg0, arg1, arg2) {
+ const ret = arg0.elementFromPoint(arg1, arg2);
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_enableVertexAttribArray_10d871fb9fd0846c = function(arg0, arg1) {
+ arg0.enableVertexAttribArray(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_enableVertexAttribArray_a2d36c7d18a4a692 = function(arg0, arg1) {
+ arg0.enableVertexAttribArray(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_enable_3c4fab29e1f03b55 = function(arg0, arg1) {
+ arg0.enable(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_enable_e086a91d756e13d4 = function(arg0, arg1) {
+ arg0.enable(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+ let deferred0_0;
+ let deferred0_1;
+ try {
+ deferred0_0 = arg0;
+ deferred0_1 = arg1;
+ console.error(getStringFromWasm0(arg0, arg1));
+ } finally {
+ wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+ }
+ };
+ imports.wbg.__wbg_error_9e96f6dc2ec8f160 = function(arg0, arg1) {
+ let deferred0_0;
+ let deferred0_1;
+ try {
+ deferred0_0 = arg0;
+ deferred0_1 = arg1;
+ console.error(getStringFromWasm0(arg0, arg1));
+ } finally {
+ wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+ }
+ };
+ imports.wbg.__wbg_features_dafff7dd39a9b665 = function(arg0) {
+ const ret = arg0.features;
+ return ret;
+ };
+ imports.wbg.__wbg_files_b3322d9a4bdc60ef = function(arg0) {
+ const ret = arg0.files;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_focus_f18e304f287a2dd3 = function() { return handleError(function (arg0) {
+ arg0.focus();
+ }, arguments) };
+ imports.wbg.__wbg_force_eb1a0ff68a50a61d = function(arg0) {
+ const ret = arg0.force;
+ return ret;
+ };
+ imports.wbg.__wbg_generateMipmap_a4d48a9eb569ee7b = function(arg0, arg1) {
+ arg0.generateMipmap(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_generateMipmap_f14e38fd660f54c4 = function(arg0, arg1) {
+ arg0.generateMipmap(arg1 >>> 0);
+ };
+ imports.wbg.__wbg_getAttribLocation_49bd303d768cecdc = function(arg0, arg1, arg2, arg3) {
+ const ret = arg0.getAttribLocation(arg1, getStringFromWasm0(arg2, arg3));
+ return ret;
+ };
+ imports.wbg.__wbg_getAttribLocation_b544bb90d1c65c92 = function(arg0, arg1, arg2, arg3) {
+ const ret = arg0.getAttribLocation(arg1, getStringFromWasm0(arg2, arg3));
+ return ret;
+ };
+ imports.wbg.__wbg_getBoundingClientRect_eb2f68e504025fb4 = function(arg0) {
+ const ret = arg0.getBoundingClientRect();
+ return ret;
+ };
+ imports.wbg.__wbg_getComputedStyle_a9cd917337bb8d6e = function() { return handleError(function (arg0, arg1) {
+ const ret = arg0.getComputedStyle(arg1);
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ }, arguments) };
+ imports.wbg.__wbg_getContext_0b80ccb9547db509 = function() { return handleError(function (arg0, arg1, arg2) {
+ const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ }, arguments) };
+ imports.wbg.__wbg_getData_3788e2545bd763f8 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+ const ret = arg1.getData(getStringFromWasm0(arg2, arg3));
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_getElementById_c365dd703c4a88c3 = function(arg0, arg1, arg2) {
+ const ret = arg0.getElementById(getStringFromWasm0(arg1, arg2));
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_getError_0f97dbb7af4af28b = function(arg0) {
+ const ret = arg0.getError();
+ return ret;
+ };
+ imports.wbg.__wbg_getError_63344ab78b980409 = function(arg0) {
+ const ret = arg0.getError();
+ return ret;
+ };
+ imports.wbg.__wbg_getExtension_44f035398aceaa92 = function() { return handleError(function (arg0, arg1, arg2) {
+ const ret = arg0.getExtension(getStringFromWasm0(arg1, arg2));
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ }, arguments) };
+ imports.wbg.__wbg_getExtension_bbf0b2c292c17fd9 = function() { return handleError(function (arg0, arg1, arg2) {
+ const ret = arg0.getExtension(getStringFromWasm0(arg1, arg2));
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ }, arguments) };
+ imports.wbg.__wbg_getItem_89f57d6acc51a876 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+ const ret = arg1.getItem(getStringFromWasm0(arg2, arg3));
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_getParameter_1b50ca7ab8b81a6c = function() { return handleError(function (arg0, arg1) {
+ const ret = arg0.getParameter(arg1 >>> 0);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_getParameter_4261d100d0d13cdd = function() { return handleError(function (arg0, arg1) {
+ const ret = arg0.getParameter(arg1 >>> 0);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_getProgramInfoLog_579753d7443e93d0 = function(arg0, arg1, arg2) {
+ const ret = arg1.getProgramInfoLog(arg2);
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_getProgramInfoLog_ce6f5e0603a4927f = function(arg0, arg1, arg2) {
+ const ret = arg1.getProgramInfoLog(arg2);
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_getProgramParameter_9e84a8e91d9bd349 = function(arg0, arg1, arg2) {
+ const ret = arg0.getProgramParameter(arg1, arg2 >>> 0);
+ return ret;
+ };
+ imports.wbg.__wbg_getProgramParameter_c7c229864f96a134 = function(arg0, arg1, arg2) {
+ const ret = arg0.getProgramParameter(arg1, arg2 >>> 0);
+ return ret;
+ };
+ imports.wbg.__wbg_getPropertyValue_6d3f3b556847452f = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+ const ret = arg1.getPropertyValue(getStringFromWasm0(arg2, arg3));
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_getRandomValues_1c61fac11405ffdc = function() { return handleError(function (arg0, arg1) {
+ globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+ }, arguments) };
+ imports.wbg.__wbg_getRootNode_1a92832d2a2c2584 = function(arg0) {
+ const ret = arg0.getRootNode();
+ return ret;
+ };
+ imports.wbg.__wbg_getShaderInfoLog_77e0c47daa4370bb = function(arg0, arg1, arg2) {
+ const ret = arg1.getShaderInfoLog(arg2);
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_getShaderInfoLog_8802198fabe2d112 = function(arg0, arg1, arg2) {
+ const ret = arg1.getShaderInfoLog(arg2);
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ var len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_getShaderParameter_e3163f97690735a5 = function(arg0, arg1, arg2) {
+ const ret = arg0.getShaderParameter(arg1, arg2 >>> 0);
+ return ret;
+ };
+ imports.wbg.__wbg_getShaderParameter_f7a968e7357add60 = function(arg0, arg1, arg2) {
+ const ret = arg0.getShaderParameter(arg1, arg2 >>> 0);
+ return ret;
+ };
+ imports.wbg.__wbg_getSupportedExtensions_2ebb12658429578b = function(arg0) {
+ const ret = arg0.getSupportedExtensions();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_getSupportedExtensions_b646b9d1a2bc4476 = function(arg0) {
+ const ret = arg0.getSupportedExtensions();
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_getUniformLocation_595d98b1f60ef0bd = function(arg0, arg1, arg2, arg3) {
+ const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_getUniformLocation_eec60dd414033654 = function(arg0, arg1, arg2, arg3) {
+ const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_get_6657bdb7125f55e6 = function(arg0, arg1) {
+ const ret = arg0[arg1 >>> 0];
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_get_7bed016f185add81 = function(arg0, arg1) {
+ const ret = arg0[arg1 >>> 0];
+ return ret;
+ };
+ imports.wbg.__wbg_get_cf5c9f2800c60966 = function(arg0, arg1) {
+ const ret = arg0[arg1 >>> 0];
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_get_e87449b189af3c78 = function(arg0, arg1) {
+ const ret = arg0[arg1 >>> 0];
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_get_efcb449f58ec27c2 = function() { return handleError(function (arg0, arg1) {
+ const ret = Reflect.get(arg0, arg1);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_has_e7b9469a0ae9abd2 = function(arg0, arg1, arg2) {
+ const ret = arg0.has(getStringFromWasm0(arg1, arg2));
+ return ret;
+ };
+ imports.wbg.__wbg_hash_2aa6a54fb8342cef = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.hash;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_height_119077665279308c = function(arg0) {
+ const ret = arg0.height;
+ return ret;
+ };
+ imports.wbg.__wbg_height_4ec1d9540f62ef0a = function(arg0) {
+ const ret = arg0.height;
+ return ret;
+ };
+ imports.wbg.__wbg_hidden_e2d0392f3af0749f = function(arg0) {
+ const ret = arg0.hidden;
+ return ret;
+ };
+ imports.wbg.__wbg_host_42828f818b9dc26c = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.host;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_hostname_b3afa4677fba29d1 = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.hostname;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_href_6d02c53ff820b6ae = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.href;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_id_d58b7351e62811fa = function(arg0, arg1) {
+ const ret = arg1.id;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_identifier_62287c55f12f8d26 = function(arg0) {
+ const ret = arg0.identifier;
+ return ret;
+ };
+ imports.wbg.__wbg_inlineSize_917f52e805414525 = function(arg0) {
+ const ret = arg0.inlineSize;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_Document_c741de15f1a592fa = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof Document;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_Element_437534ce3e96fe49 = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof Element;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_HtmlCanvasElement_3e2e95b109dae976 = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof HTMLCanvasElement;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_HtmlElement_e20a729df22f9e1c = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof HTMLElement;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_HtmlInputElement_b8672abb32fe4ab7 = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof HTMLInputElement;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_ResizeObserverEntry_f5dd16c0b18c0095 = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof ResizeObserverEntry;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_ResizeObserverSize_614222674456d4e1 = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof ResizeObserverSize;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_ShadowRoot_e6792e25a38f0857 = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof ShadowRoot;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_WebGl2RenderingContext_21eea93591d7c571 = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof WebGL2RenderingContext;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_WebGlRenderingContext_29ac37f0cb7afc9b = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof WebGLRenderingContext;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_instanceof_Window_4846dbb3de56c84c = function(arg0) {
+ let result;
+ try {
+ result = arg0 instanceof Window;
+ } catch (_) {
+ result = false;
+ }
+ const ret = result;
+ return ret;
+ };
+ imports.wbg.__wbg_isComposing_880aefe4b7c1f188 = function(arg0) {
+ const ret = arg0.isComposing;
+ return ret;
+ };
+ imports.wbg.__wbg_isComposing_edc391922399c564 = function(arg0) {
+ const ret = arg0.isComposing;
+ return ret;
+ };
+ imports.wbg.__wbg_isSecureContext_5de99ce3634f8265 = function(arg0) {
+ const ret = arg0.isSecureContext;
+ return ret;
+ };
+ imports.wbg.__wbg_is_3a0656e6f61f2e9a = function(arg0, arg1) {
+ const ret = Object.is(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbg_item_b844543d1e47f842 = function(arg0, arg1) {
+ const ret = arg0.item(arg1 >>> 0);
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_items_6f6ee442137b5379 = function(arg0) {
+ const ret = arg0.items;
+ return ret;
+ };
+ imports.wbg.__wbg_keyCode_065f5848e677fafd = function(arg0) {
+ const ret = arg0.keyCode;
+ return ret;
+ };
+ imports.wbg.__wbg_key_32aa43e1cae08d29 = function(arg0, arg1) {
+ const ret = arg1.key;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_lastModified_8a42a70c9d48f5d1 = function(arg0) {
+ const ret = arg0.lastModified;
+ return ret;
+ };
+ imports.wbg.__wbg_left_899de713c50d5346 = function(arg0) {
+ const ret = arg0.left;
+ return ret;
+ };
+ imports.wbg.__wbg_length_69bca3cb64fc8748 = function(arg0) {
+ const ret = arg0.length;
+ return ret;
+ };
+ imports.wbg.__wbg_length_7ac941be82f614bb = function(arg0) {
+ const ret = arg0.length;
+ return ret;
+ };
+ imports.wbg.__wbg_length_7b84328ffb2e7b44 = function(arg0) {
+ const ret = arg0.length;
+ return ret;
+ };
+ imports.wbg.__wbg_length_cdd215e10d9dd507 = function(arg0) {
+ const ret = arg0.length;
+ return ret;
+ };
+ imports.wbg.__wbg_length_dc1fcbb3c4169df7 = function(arg0) {
+ const ret = arg0.length;
+ return ret;
+ };
+ imports.wbg.__wbg_limits_22116faf3a912173 = function(arg0) {
+ const ret = arg0.limits;
+ return ret;
+ };
+ imports.wbg.__wbg_linkProgram_18ffcc2016a8ef92 = function(arg0, arg1) {
+ arg0.linkProgram(arg1);
+ };
+ imports.wbg.__wbg_linkProgram_95ada1a5ea318894 = function(arg0, arg1) {
+ arg0.linkProgram(arg1);
+ };
+ imports.wbg.__wbg_localStorage_3034501cd2b3da3f = function() { return handleError(function (arg0) {
+ const ret = arg0.localStorage;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ }, arguments) };
+ imports.wbg.__wbg_location_ef1665506d996dd9 = function(arg0) {
+ const ret = arg0.location;
+ return ret;
+ };
+ imports.wbg.__wbg_matchMedia_711d65a9da8824cf = function() { return handleError(function (arg0, arg1, arg2) {
+ const ret = arg0.matchMedia(getStringFromWasm0(arg1, arg2));
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ }, arguments) };
+ imports.wbg.__wbg_matches_52e77fafd1b3a974 = function(arg0) {
+ const ret = arg0.matches;
+ return ret;
+ };
+ imports.wbg.__wbg_maxBindGroups_af2c64a371bc64b2 = function(arg0) {
+ const ret = arg0.maxBindGroups;
+ return ret;
+ };
+ imports.wbg.__wbg_maxBindingsPerBindGroup_430f6510523172d9 = function(arg0) {
+ const ret = arg0.maxBindingsPerBindGroup;
+ return ret;
+ };
+ imports.wbg.__wbg_maxBufferSize_68b45c1b69c22207 = function(arg0) {
+ const ret = arg0.maxBufferSize;
+ return ret;
+ };
+ imports.wbg.__wbg_maxColorAttachmentBytesPerSample_cbfce6f5737b4853 = function(arg0) {
+ const ret = arg0.maxColorAttachmentBytesPerSample;
+ return ret;
+ };
+ imports.wbg.__wbg_maxColorAttachments_70e7c33a58d9fc56 = function(arg0) {
+ const ret = arg0.maxColorAttachments;
+ return ret;
+ };
+ imports.wbg.__wbg_maxComputeInvocationsPerWorkgroup_4ad21bf35b7bd17f = function(arg0) {
+ const ret = arg0.maxComputeInvocationsPerWorkgroup;
+ return ret;
+ };
+ imports.wbg.__wbg_maxComputeWorkgroupSizeX_854c87a3ea2e5a00 = function(arg0) {
+ const ret = arg0.maxComputeWorkgroupSizeX;
+ return ret;
+ };
+ imports.wbg.__wbg_maxComputeWorkgroupSizeY_965ebcb7fee4acf5 = function(arg0) {
+ const ret = arg0.maxComputeWorkgroupSizeY;
+ return ret;
+ };
+ imports.wbg.__wbg_maxComputeWorkgroupSizeZ_3bf468106936874c = function(arg0) {
+ const ret = arg0.maxComputeWorkgroupSizeZ;
+ return ret;
+ };
+ imports.wbg.__wbg_maxComputeWorkgroupStorageSize_b9cab4f75b0f03e3 = function(arg0) {
+ const ret = arg0.maxComputeWorkgroupStorageSize;
+ return ret;
+ };
+ imports.wbg.__wbg_maxComputeWorkgroupsPerDimension_f4664066d76015da = function(arg0) {
+ const ret = arg0.maxComputeWorkgroupsPerDimension;
+ return ret;
+ };
+ imports.wbg.__wbg_maxDynamicStorageBuffersPerPipelineLayout_6b7faf56a6e328ad = function(arg0) {
+ const ret = arg0.maxDynamicStorageBuffersPerPipelineLayout;
+ return ret;
+ };
+ imports.wbg.__wbg_maxDynamicUniformBuffersPerPipelineLayout_22a38cc27e2f4626 = function(arg0) {
+ const ret = arg0.maxDynamicUniformBuffersPerPipelineLayout;
+ return ret;
+ };
+ imports.wbg.__wbg_maxSampledTexturesPerShaderStage_97c70c39fb197a2b = function(arg0) {
+ const ret = arg0.maxSampledTexturesPerShaderStage;
+ return ret;
+ };
+ imports.wbg.__wbg_maxSamplersPerShaderStage_a148c7e536a3807c = function(arg0) {
+ const ret = arg0.maxSamplersPerShaderStage;
+ return ret;
+ };
+ imports.wbg.__wbg_maxStorageBufferBindingSize_bfaa9c302ad157e3 = function(arg0) {
+ const ret = arg0.maxStorageBufferBindingSize;
+ return ret;
+ };
+ imports.wbg.__wbg_maxStorageBuffersPerShaderStage_463d04005d78f248 = function(arg0) {
+ const ret = arg0.maxStorageBuffersPerShaderStage;
+ return ret;
+ };
+ imports.wbg.__wbg_maxStorageTexturesPerShaderStage_3fe774bbe6ad1371 = function(arg0) {
+ const ret = arg0.maxStorageTexturesPerShaderStage;
+ return ret;
+ };
+ imports.wbg.__wbg_maxTextureArrayLayers_6b1a7b0b3b4c0556 = function(arg0) {
+ const ret = arg0.maxTextureArrayLayers;
+ return ret;
+ };
+ imports.wbg.__wbg_maxTextureDimension1D_e79117695a706815 = function(arg0) {
+ const ret = arg0.maxTextureDimension1D;
+ return ret;
+ };
+ imports.wbg.__wbg_maxTextureDimension2D_cbb3e7343bea93d1 = function(arg0) {
+ const ret = arg0.maxTextureDimension2D;
+ return ret;
+ };
+ imports.wbg.__wbg_maxTextureDimension3D_7ac996fb8fe18286 = function(arg0) {
+ const ret = arg0.maxTextureDimension3D;
+ return ret;
+ };
+ imports.wbg.__wbg_maxUniformBufferBindingSize_22c4f55b73d306cf = function(arg0) {
+ const ret = arg0.maxUniformBufferBindingSize;
+ return ret;
+ };
+ imports.wbg.__wbg_maxUniformBuffersPerShaderStage_65e2b2eaf78ef4e1 = function(arg0) {
+ const ret = arg0.maxUniformBuffersPerShaderStage;
+ return ret;
+ };
+ imports.wbg.__wbg_maxVertexAttributes_a6c97c2dc4a8d443 = function(arg0) {
+ const ret = arg0.maxVertexAttributes;
+ return ret;
+ };
+ imports.wbg.__wbg_maxVertexBufferArrayStride_305ba73c4de05f82 = function(arg0) {
+ const ret = arg0.maxVertexBufferArrayStride;
+ return ret;
+ };
+ imports.wbg.__wbg_maxVertexBuffers_df4a4911d2c540d8 = function(arg0) {
+ const ret = arg0.maxVertexBuffers;
+ return ret;
+ };
+ imports.wbg.__wbg_metaKey_5e1cfce6326629a8 = function(arg0) {
+ const ret = arg0.metaKey;
+ return ret;
+ };
+ imports.wbg.__wbg_metaKey_a1cde9a816929936 = function(arg0) {
+ const ret = arg0.metaKey;
+ return ret;
+ };
+ imports.wbg.__wbg_minStorageBufferOffsetAlignment_12d731adbf75fd21 = function(arg0) {
+ const ret = arg0.minStorageBufferOffsetAlignment;
+ return ret;
+ };
+ imports.wbg.__wbg_minUniformBufferOffsetAlignment_2a0a0d2e84c280a7 = function(arg0) {
+ const ret = arg0.minUniformBufferOffsetAlignment;
+ return ret;
+ };
+ imports.wbg.__wbg_name_2922909227d511f5 = function(arg0, arg1) {
+ const ret = arg1.name;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_navigator_971384882e8ea23a = function(arg0) {
+ const ret = arg0.navigator;
+ return ret;
+ };
+ imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {
+ const ret = new Object();
+ return ret;
+ };
+ imports.wbg.__wbg_new_5a79be3ab53b8aa5 = function(arg0) {
+ const ret = new Uint8Array(arg0);
+ return ret;
+ };
+ imports.wbg.__wbg_new_85a4defe7ad17c22 = function() {
+ const ret = new Error();
+ return ret;
+ };
+ imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+ const ret = new Error();
+ return ret;
+ };
+ imports.wbg.__wbg_new_b909111eafced042 = function() { return handleError(function (arg0) {
+ const ret = new ResizeObserver(arg0);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_new_e17d9f43105b08be = function() {
+ const ret = new Array();
+ return ret;
+ };
+ imports.wbg.__wbg_new_from_slice_92f4d78ca282a2d2 = function(arg0, arg1) {
+ const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+ return ret;
+ };
+ imports.wbg.__wbg_new_no_args_ee98eee5275000a4 = function(arg0, arg1) {
+ const ret = new Function(getStringFromWasm0(arg0, arg1));
+ return ret;
+ };
+ imports.wbg.__wbg_new_with_record_from_str_to_blob_promise_cdef046f8d46ab5b = function() { return handleError(function (arg0) {
+ const ret = new ClipboardItem(arg0);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_new_with_text_4a322e0ac74817a0 = function() { return handleError(function (arg0, arg1) {
+ const ret = new SpeechSynthesisUtterance(getStringFromWasm0(arg0, arg1));
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_new_with_u8_array_sequence_and_options_0c1d0bd56d93d25a = function() { return handleError(function (arg0, arg1) {
+ const ret = new Blob(arg0, arg1);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_now_2c95c9de01293173 = function(arg0) {
+ const ret = arg0.now();
+ return ret;
+ };
+ imports.wbg.__wbg_now_f5ba683d8ce2c571 = function(arg0) {
+ const ret = arg0.now();
+ return ret;
+ };
+ imports.wbg.__wbg_observe_228709a845044950 = function(arg0, arg1, arg2) {
+ arg0.observe(arg1, arg2);
+ };
+ imports.wbg.__wbg_of_035271b9e67a3bd9 = function(arg0) {
+ const ret = Array.of(arg0);
+ return ret;
+ };
+ imports.wbg.__wbg_offsetTop_e7becacb6a76a499 = function(arg0) {
+ const ret = arg0.offsetTop;
+ return ret;
+ };
+ imports.wbg.__wbg_open_2fa659dfc3f6d723 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+ const ret = arg0.open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ }, arguments) };
+ imports.wbg.__wbg_origin_2b5e7986f349f4f3 = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.origin;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_performance_7a3ffd0b17f663ad = function(arg0) {
+ const ret = arg0.performance;
+ return ret;
+ };
+ imports.wbg.__wbg_performance_e8315b5ae987e93f = function(arg0) {
+ const ret = arg0.performance;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_pixelStorei_1e29a64e4b8b9b03 = function(arg0, arg1, arg2) {
+ arg0.pixelStorei(arg1 >>> 0, arg2);
+ };
+ imports.wbg.__wbg_pixelStorei_bb82795e08644ed9 = function(arg0, arg1, arg2) {
+ arg0.pixelStorei(arg1 >>> 0, arg2);
+ };
+ imports.wbg.__wbg_port_3600de3e4e460160 = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.port;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_preventDefault_1f362670ce7ef430 = function(arg0) {
+ arg0.preventDefault();
+ };
+ imports.wbg.__wbg_protocol_3fa0fc2db8145bfb = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.protocol;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+ };
+ imports.wbg.__wbg_push_df81a39d04db858c = function(arg0, arg1) {
+ const ret = arg0.push(arg1);
+ return ret;
+ };
+ imports.wbg.__wbg_queueMicrotask_34d692c25c47d05b = function(arg0) {
+ const ret = arg0.queueMicrotask;
+ return ret;
+ };
+ imports.wbg.__wbg_queueMicrotask_9d76cacb20c84d58 = function(arg0) {
+ queueMicrotask(arg0);
+ };
+ imports.wbg.__wbg_queue_e7ab52ab0880dce9 = function(arg0) {
+ const ret = arg0.queue;
+ return ret;
+ };
+ imports.wbg.__wbg_readPixels_0d03ebdf3d0d157c = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+ arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
+ }, arguments) };
+ imports.wbg.__wbg_readPixels_d2e13d1e3525be28 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+ arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
+ }, arguments) };
+ imports.wbg.__wbg_readPixels_fe98362668ca0295 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+ arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
+ }, arguments) };
+ imports.wbg.__wbg_removeEventListener_aa21ef619e743518 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+ arg0.removeEventListener(getStringFromWasm0(arg1, arg2), arg3);
+ }, arguments) };
+ imports.wbg.__wbg_remove_4ba46706a8e17d9d = function(arg0) {
+ arg0.remove();
+ };
+ imports.wbg.__wbg_requestAnimationFrame_7ecf8bfece418f08 = function() { return handleError(function (arg0, arg1) {
+ const ret = arg0.requestAnimationFrame(arg1);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_requestDevice_1be6e30ff9d67933 = function(arg0, arg1) {
+ const ret = arg0.requestDevice(arg1);
+ return ret;
+ };
+ imports.wbg.__wbg_resolve_caf97c30b83f7053 = function(arg0) {
+ const ret = Promise.resolve(arg0);
+ return ret;
+ };
+ imports.wbg.__wbg_right_bec501ed000bfe81 = function(arg0) {
+ const ret = arg0.right;
+ return ret;
+ };
+ imports.wbg.__wbg_run_e5e1ecccf06974b2 = function(arg0, arg1, arg2) {
+ try {
+ var state0 = {a: arg1, b: arg2};
+ var cb0 = () => {
+ const a = state0.a;
+ state0.a = 0;
+ try {
+ return wasm_bindgen__convert__closures_____invoke__hbac06d5f8f19c42d(a, state0.b, );
+ } finally {
+ state0.a = a;
+ }
+ };
+ const ret = arg0.run(cb0);
+ return ret;
+ } finally {
+ state0.a = state0.b = 0;
+ }
+ };
+ imports.wbg.__wbg_scissor_486e259b969a99fa = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.scissor(arg1, arg2, arg3, arg4);
+ };
+ imports.wbg.__wbg_scissor_8dc97f3cd80c6d04 = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.scissor(arg1, arg2, arg3, arg4);
+ };
+ imports.wbg.__wbg_search_86f864580e97479d = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.search;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_setAttribute_9bad76f39609daac = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+ arg0.setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+ }, arguments) };
+ imports.wbg.__wbg_setItem_64dfb54d7b20d84c = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+ arg0.setItem(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+ }, arguments) };
+ imports.wbg.__wbg_setProperty_7b188d7e71d4aca8 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+ arg0.setProperty(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+ }, arguments) };
+ imports.wbg.__wbg_set_autofocus_b0877c61b61f9fb8 = function() { return handleError(function (arg0, arg1) {
+ arg0.autofocus = arg1 !== 0;
+ }, arguments) };
+ imports.wbg.__wbg_set_box_5e651af64b5f1213 = function(arg0, arg1) {
+ arg0.box = __wbindgen_enum_ResizeObserverBoxOptions[arg1];
+ };
+ imports.wbg.__wbg_set_c2abbebe8b9ebee1 = function() { return handleError(function (arg0, arg1, arg2) {
+ const ret = Reflect.set(arg0, arg1, arg2);
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_set_height_89110f48f7fd0817 = function(arg0, arg1) {
+ arg0.height = arg1 >>> 0;
+ };
+ imports.wbg.__wbg_set_label_e69d774bf38947d2 = function(arg0, arg1, arg2) {
+ arg0.label = getStringFromWasm0(arg1, arg2);
+ };
+ imports.wbg.__wbg_set_once_6faa794a6bcd7d25 = function(arg0, arg1) {
+ arg0.once = arg1 !== 0;
+ };
+ imports.wbg.__wbg_set_pitch_53dc4e87b82173f2 = function(arg0, arg1) {
+ arg0.pitch = arg1;
+ };
+ imports.wbg.__wbg_set_rate_5b1f22b6ff887d8a = function(arg0, arg1) {
+ arg0.rate = arg1;
+ };
+ imports.wbg.__wbg_set_required_features_52447a9e50ed9b36 = function(arg0, arg1) {
+ arg0.requiredFeatures = arg1;
+ };
+ imports.wbg.__wbg_set_tabIndex_e7779a059c59f7d8 = function(arg0, arg1) {
+ arg0.tabIndex = arg1;
+ };
+ imports.wbg.__wbg_set_type_3d1ac6cb9b3c2411 = function(arg0, arg1, arg2) {
+ arg0.type = getStringFromWasm0(arg1, arg2);
+ };
+ imports.wbg.__wbg_set_type_63fa4c18251f6545 = function(arg0, arg1, arg2) {
+ arg0.type = getStringFromWasm0(arg1, arg2);
+ };
+ imports.wbg.__wbg_set_value_1fd424cb99963707 = function(arg0, arg1, arg2) {
+ arg0.value = getStringFromWasm0(arg1, arg2);
+ };
+ imports.wbg.__wbg_set_volume_24ed75919edb5ca5 = function(arg0, arg1) {
+ arg0.volume = arg1;
+ };
+ imports.wbg.__wbg_set_width_dcc02c61dd01cff6 = function(arg0, arg1) {
+ arg0.width = arg1 >>> 0;
+ };
+ imports.wbg.__wbg_shaderSource_328f9044e2c98a85 = function(arg0, arg1, arg2, arg3) {
+ arg0.shaderSource(arg1, getStringFromWasm0(arg2, arg3));
+ };
+ imports.wbg.__wbg_shaderSource_3d2fab949529ee31 = function(arg0, arg1, arg2, arg3) {
+ arg0.shaderSource(arg1, getStringFromWasm0(arg2, arg3));
+ };
+ imports.wbg.__wbg_shiftKey_02a93ca3ce31a4f4 = function(arg0) {
+ const ret = arg0.shiftKey;
+ return ret;
+ };
+ imports.wbg.__wbg_shiftKey_e0b189884cc0d006 = function(arg0) {
+ const ret = arg0.shiftKey;
+ return ret;
+ };
+ imports.wbg.__wbg_size_0a5a003dbf5dfee8 = function(arg0) {
+ const ret = arg0.size;
+ return ret;
+ };
+ imports.wbg.__wbg_speak_24aad9e81c99cf31 = function(arg0, arg1) {
+ arg0.speak(arg1);
+ };
+ imports.wbg.__wbg_speechSynthesis_572380a3a02f109e = function() { return handleError(function (arg0) {
+ const ret = arg0.speechSynthesis;
+ return ret;
+ }, arguments) };
+ imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+ const ret = arg1.stack;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_stack_c4052f73ae6c538a = function(arg0, arg1) {
+ const ret = arg1.stack;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {
+ const ret = typeof global === 'undefined' ? null : global;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac = function() {
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_static_accessor_SELF_6fdf4b64710cc91b = function() {
+ const ret = typeof self === 'undefined' ? null : self;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2 = function() {
+ const ret = typeof window === 'undefined' ? null : window;
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+ };
+ imports.wbg.__wbg_stopPropagation_c77434a66c3604c3 = function(arg0) {
+ arg0.stopPropagation();
+ };
+ imports.wbg.__wbg_style_763a7ccfd47375da = function(arg0) {
+ const ret = arg0.style;
+ return ret;
+ };
+ imports.wbg.__wbg_texImage2D_17fddf27ffd77cad = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+ arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+ }, arguments) };
+ imports.wbg.__wbg_texImage2D_c6af39a17286ae67 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+ arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+ }, arguments) };
+ imports.wbg.__wbg_texImage2D_c83ec45089cb6aca = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+ arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+ }, arguments) };
+ imports.wbg.__wbg_texParameteri_20dfff54dc2efc8b = function(arg0, arg1, arg2, arg3) {
+ arg0.texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
+ };
+ imports.wbg.__wbg_texParameteri_b2871a22f57e806d = function(arg0, arg1, arg2, arg3) {
+ arg0.texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
+ };
+ imports.wbg.__wbg_texSubImage2D_1c1567eb7be0a2e3 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+ }, arguments) };
+ imports.wbg.__wbg_texSubImage2D_4fe6aa0c7b8c95e7 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+ }, arguments) };
+ imports.wbg.__wbg_texSubImage2D_7d74ab027406c91e = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+ }, arguments) };
+ imports.wbg.__wbg_then_4f46f6544e6b4a28 = function(arg0, arg1) {
+ const ret = arg0.then(arg1);
+ return ret;
+ };
+ imports.wbg.__wbg_then_70d05cf780a18d77 = function(arg0, arg1, arg2) {
+ const ret = arg0.then(arg1, arg2);
+ return ret;
+ };
+ imports.wbg.__wbg_top_e4eeead6b19051fb = function(arg0) {
+ const ret = arg0.top;
+ return ret;
+ };
+ imports.wbg.__wbg_touches_bec8a0e164b02c16 = function(arg0) {
+ const ret = arg0.touches;
+ return ret;
+ };
+ imports.wbg.__wbg_type_c146e3ebeb6d6284 = function(arg0, arg1) {
+ const ret = arg1.type;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_type_d5d4dbe840f65b14 = function(arg0, arg1) {
+ const ret = arg1.type;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_uniform1i_23e72424961ee8d0 = function(arg0, arg1, arg2) {
+ arg0.uniform1i(arg1, arg2);
+ };
+ imports.wbg.__wbg_uniform1i_fe4307a416c7e7aa = function(arg0, arg1, arg2) {
+ arg0.uniform1i(arg1, arg2);
+ };
+ imports.wbg.__wbg_uniform2f_24cdd97984906bea = function(arg0, arg1, arg2, arg3) {
+ arg0.uniform2f(arg1, arg2, arg3);
+ };
+ imports.wbg.__wbg_uniform2f_587619767a15ed7e = function(arg0, arg1, arg2, arg3) {
+ arg0.uniform2f(arg1, arg2, arg3);
+ };
+ imports.wbg.__wbg_useProgram_20101ed5f7e0d637 = function(arg0, arg1) {
+ arg0.useProgram(arg1);
+ };
+ imports.wbg.__wbg_useProgram_3cc28f936528f842 = function(arg0, arg1) {
+ arg0.useProgram(arg1);
+ };
+ imports.wbg.__wbg_userAgent_b20949aa6be940a6 = function() { return handleError(function (arg0, arg1) {
+ const ret = arg1.userAgent;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ }, arguments) };
+ imports.wbg.__wbg_value_f470db44e5a60ad8 = function(arg0, arg1) {
+ const ret = arg1.value;
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ const len1 = WASM_VECTOR_LEN;
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+ };
+ imports.wbg.__wbg_vertexAttribPointer_316e3d795c40b758 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+ arg0.vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
+ };
+ imports.wbg.__wbg_vertexAttribPointer_4c4826c855c381d0 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+ arg0.vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
+ };
+ imports.wbg.__wbg_viewport_6e8b657130b529c0 = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.viewport(arg1, arg2, arg3, arg4);
+ };
+ imports.wbg.__wbg_viewport_774feeb955171e3d = function(arg0, arg1, arg2, arg3, arg4) {
+ arg0.viewport(arg1, arg2, arg3, arg4);
+ };
+ imports.wbg.__wbg_width_9ea2df52b5d2c909 = function(arg0) {
+ const ret = arg0.width;
+ return ret;
+ };
+ imports.wbg.__wbg_width_d02e5c8cc6e335b7 = function(arg0) {
+ const ret = arg0.width;
+ return ret;
+ };
+ imports.wbg.__wbg_writeText_0337219b13348e84 = function(arg0, arg1, arg2) {
+ const ret = arg0.writeText(getStringFromWasm0(arg1, arg2));
+ return ret;
+ };
+ imports.wbg.__wbg_write_9bf74e4aa45bf5d6 = function(arg0, arg1) {
+ const ret = arg0.write(arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_0903e011e606afe0 = function(arg0, arg1) {
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 253, function: Function { arguments: [NamedExternref("Array")], shim_idx: 254, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+ const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h6be278b18e5a0654, wasm_bindgen__convert__closures_____invoke__h149fdb4773432f0b);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(String) -> Externref`.
+ const ret = getStringFromWasm0(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_7c316abdc43840a3 = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(Slice(U32)) -> NamedExternref("Uint32Array")`.
+ const ret = getArrayU32FromWasm0(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_8679464c88ab5087 = function(arg0, arg1) {
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 347, function: Function { arguments: [Externref], shim_idx: 348, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+ const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h5bf883fc5f7df6da, wasm_bindgen__convert__closures_____invoke__h2e9715ce298bdfd4);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_9575fb55a66c262b = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(Slice(I32)) -> NamedExternref("Int32Array")`.
+ const ret = getArrayI32FromWasm0(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_bbb4883c6389f1de = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(Slice(U16)) -> NamedExternref("Uint16Array")`.
+ const ret = getArrayU16FromWasm0(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_c33787348bfb30ee = function(arg0, arg1) {
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 255, function: Function { arguments: [], shim_idx: 256, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+ const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h07d3f424af2c92f4, wasm_bindgen__convert__closures_____invoke__haa4abc61e2c846b6);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+ const ret = getArrayU8FromWasm0(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_cd07b1914aa3d62c = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.
+ const ret = getArrayF32FromWasm0(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+ // Cast intrinsic for `F64 -> Externref`.
+ const ret = arg0;
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_e47ceb6027f5c92c = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(Slice(I16)) -> NamedExternref("Int16Array")`.
+ const ret = getArrayI16FromWasm0(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_e979934cecb74573 = function(arg0, arg1) {
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 251, function: Function { arguments: [NamedExternref("Event")], shim_idx: 252, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+ const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hab7fc4815c20c54d, wasm_bindgen__convert__closures_____invoke__h8ae3b4a2c216dc58);
+ return ret;
+ };
+ imports.wbg.__wbindgen_cast_feefb5fadd6457fd = function(arg0, arg1) {
+ // Cast intrinsic for `Ref(Slice(I8)) -> NamedExternref("Int8Array")`.
+ const ret = getArrayI8FromWasm0(arg0, arg1);
+ return ret;
+ };
+ imports.wbg.__wbindgen_init_externref_table = function() {
+ const table = wasm.__wbindgen_externrefs;
+ const offset = table.grow(4);
+ table.set(0, undefined);
+ table.set(offset + 0, undefined);
+ table.set(offset + 1, null);
+ table.set(offset + 2, true);
+ table.set(offset + 3, false);
+ ;
+ };
+
+ return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+ wasm = instance.exports;
+ __wbg_init.__wbindgen_wasm_module = module;
+ cachedDataViewMemory0 = null;
+ cachedFloat32ArrayMemory0 = null;
+ cachedInt16ArrayMemory0 = null;
+ cachedInt32ArrayMemory0 = null;
+ cachedInt8ArrayMemory0 = null;
+ cachedUint16ArrayMemory0 = null;
+ cachedUint32ArrayMemory0 = null;
+ cachedUint8ArrayMemory0 = null;
+
+
+ wasm.__wbindgen_start();
+ return wasm;
+}
+
+function initSync(module) {
+ if (wasm !== undefined) return wasm;
+
+
+ if (typeof module !== 'undefined') {
+ if (Object.getPrototypeOf(module) === Object.prototype) {
+ ({module} = module)
+ } else {
+ console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+ }
+ }
+
+ const imports = __wbg_get_imports();
+
+ if (!(module instanceof WebAssembly.Module)) {
+ module = new WebAssembly.Module(module);
+ }
+
+ const instance = new WebAssembly.Instance(module, imports);
+
+ return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+ if (wasm !== undefined) return wasm;
+
+
+ if (typeof module_or_path !== 'undefined') {
+ if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+ ({module_or_path} = module_or_path)
+ } else {
+ console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+ }
+ }
+
+ if (typeof module_or_path === 'undefined') {
+ module_or_path = new URL('code-analyzer-web_bg.wasm', import.meta.url);
+ }
+ const imports = __wbg_get_imports();
+
+ if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+ module_or_path = fetch(module_or_path);
+ }
+
+ const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+ return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;
diff --git a/crates/code-analyzer-web/dist/code-analyzer-web-7f0a84c7ccb889a2_bg.wasm b/crates/code-analyzer-web/dist/code-analyzer-web-7f0a84c7ccb889a2_bg.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..cf532817bb501cd0c32832f5813977894e8c1ac5
GIT binary patch
literal 9043274
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