diff --git a/biome.json b/biome.json index 4fa1d2fdc..8954e61bf 100644 --- a/biome.json +++ b/biome.json @@ -3,7 +3,7 @@ "vcs": { "enabled": true, "clientKind": "git", "useIgnoreFile": true }, "files": { "ignoreUnknown": false, - "includes": ["**", "!**/*.css", "!**/design/**", "!**/.worktrees/**"] + "includes": ["**", "!**/*.css", "!**/design/**", "!**/.worktrees/**", "!**/public/mediapipe/**"] }, "formatter": { "enabled": true, diff --git a/crates/Cargo.lock b/crates/Cargo.lock index dbe2f253a..940c3b7dc 100644 --- a/crates/Cargo.lock +++ b/crates/Cargo.lock @@ -44,7 +44,7 @@ version = "0.38.0+1.3.281" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f" dependencies = [ - "libloading", + "libloading 0.8.9", ] [[package]] @@ -180,7 +180,7 @@ checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4" dependencies = [ "glob", "libc", - "libloading", + "libloading 0.8.9", ] [[package]] @@ -652,7 +652,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76" dependencies = [ "libc", - "libloading", + "libloading 0.8.9", "pkg-config", ] @@ -678,6 +678,16 @@ dependencies = [ "windows-link", ] +[[package]] +name = "libloading" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60" +dependencies = [ + "cfg-if", + "windows-link", +] + [[package]] name = "libm" version = "0.2.16" @@ -720,6 +730,16 @@ dependencies = [ "libc", ] +[[package]] +name = "matrixmultiply" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7" +dependencies = [ + "autocfg", + "rawpointer", +] + [[package]] name = "memchr" version = "2.8.3" @@ -867,7 +887,37 @@ version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "427802e8ec3a734331fec1035594a210ce1ff4dc5bc1950530920ab717964ea3" dependencies = [ - "libloading", + "libloading 0.8.9", +] + +[[package]] +name = "ndarray" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841" +dependencies = [ + "matrixmultiply", + "num-complex", + "num-integer", + "num-traits", + "portable-atomic", + "portable-atomic-util", + "rawpointer", +] + +[[package]] +name = "ndarray" +version = "0.17.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "520080814a7a6b4a6e9070823bb24b4531daac8c4627e08ba5de8c5ef2f2752d" +dependencies = [ + "matrixmultiply", + "num-complex", + "num-integer", + "num-traits", + "portable-atomic", + "portable-atomic-util", + "rawpointer", ] [[package]] @@ -889,6 +939,24 @@ dependencies = [ "minimal-lexical", ] +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b" +dependencies = [ + "num-traits", +] + [[package]] name = "num-traits" version = "0.2.19" @@ -925,7 +993,9 @@ dependencies = [ "cosmic-text", "image", "metal 0.29.0", + "ndarray 0.16.1", "objc", + "ort", "pollster", "serde", "serde_json", @@ -942,6 +1012,25 @@ dependencies = [ "num-traits", ] +[[package]] +name = "ort" +version = "2.0.0-rc.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4336a1e2b38848325241c72889086886004e589b7c74f335e60a8e8db5138a0b" +dependencies = [ + "libloading 0.9.0", + "ndarray 0.17.2", + "ort-sys", + "smallvec", + "tracing", +] + +[[package]] +name = "ort-sys" +version = "2.0.0-rc.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf211e3776eea6aec988552fa118dd746d70e1b1e5e244058d1c98015f3e5872" + [[package]] name = "parking_lot" version = "0.12.5" @@ -1011,6 +1100,21 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3" +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + +[[package]] +name = "portable-atomic-util" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618" +dependencies = [ + "portable-atomic", +] + [[package]] name = "presser" version = "0.3.1" @@ -1075,6 +1179,12 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + [[package]] name = "read-fonts" version = "0.37.0" @@ -1434,6 +1544,25 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", +] + [[package]] name = "ttf-parser" version = "0.25.1" @@ -1630,7 +1759,7 @@ dependencies = [ "js-sys", "khronos-egl", "libc", - "libloading", + "libloading 0.8.9", "log", "metal 0.31.0", "naga", diff --git a/crates/Cargo.toml b/crates/Cargo.toml index 208f376cc..abd74df99 100644 --- a/crates/Cargo.toml +++ b/crates/Cargo.toml @@ -34,6 +34,26 @@ image = { version = "0.25", default-features = false, features = ["jpeg", "png"] wgpu = { version = "24", features = ["wgsl"] } pollster = "0.4" cosmic-text = "0.19" +# Inference for the webcam segmentation mask. CPU execution provider only: measured on the +# target integrated GPU it costs +0.47 ms/frame against DirectML's +1.03, its cost does not +# scale with input resolution, and choosing it deletes the whole D3D11<->D3D12 interop +# (technical-documentation/engineering/webcam-segmentation.md). +# +# Behind the `segmentation` feature and OFF by default: `download-binaries` fetches the +# ONNX Runtime libs at build time, which is a packaging decision (nix, AUR, MS Store, CI) +# that has not been taken yet. The default build is unchanged. +# `load-dynamic` et NON `download-binaries` : ce dernier tire une build STATIQUE d'ONNX +# Runtime avec DirectML dedans (DirectML.lib, DXCORE.lib et les DmlOperator* apparaissent +# dans la ligne de lien) — exactement la dépendance que le choix de l'EP CPU sert à +# supprimer. En chargement dynamique, la lib est résolue à l'exécution, ce qui laisse le +# packaging la stager par plateforme comme il le fait déjà pour whisper-stt. +ort = { version = "2.0.0-rc.13", default-features = false, features = [ + "std", + "ndarray", + "load-dynamic", + "api-27", +] } +ndarray = "0.16" [workspace.dependencies.windows] version = "0.58" diff --git a/crates/compositor/Cargo.toml b/crates/compositor/Cargo.toml index f968b5497..c9c01fc60 100644 --- a/crates/compositor/Cargo.toml +++ b/crates/compositor/Cargo.toml @@ -12,8 +12,18 @@ path = "src/lib.rs" bindgen = "0.70" cc = "1" +[features] +default = [] +# Segmentation IA de la webcam via ONNX Runtime (EP CPU). Désactivée par défaut : elle tire +# les binaires d'ONNX Runtime au build, ce qui engage le packaging des cinq canaux de +# distribution. Le chemin masque->shader, lui, est toujours compilé — sans masque l'effet +# reste simplement éteint. +segmentation = ["dep:ort", "dep:ndarray"] + [dependencies] anyhow.workspace = true +ort = { workspace = true, optional = true } +ndarray = { workspace = true, optional = true } serde.workspace = true serde_json.workspace = true image.workspace = true diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rs index 51c3a3a28..e59518b48 100644 --- a/crates/compositor/src/compositor_windows.rs +++ b/crates/compositor/src/compositor_windows.rs @@ -46,6 +46,27 @@ use windows::Win32::Graphics::Dxgi::Common::*; +/// Cadence de l'inférence. Pas 60 : une silhouette ne bouge pas de façon perceptible en +/// 16 ms, et c'est le seul levier mesuré qui divise le coût par deux sans toucher au modèle. +const SEGMENTATION_HZ: u32 = 30; + +/// Cible RGBA + staging CPU pour l'extraction de la frame webcam qui alimente le modèle. +struct SegCapture { + rtv: ID3D11RenderTargetView, + rt: ID3D11Texture2D, + staging: ID3D11Texture2D, + width: u32, + height: u32, +} + +/// Texture du masque de segmentation, recréée seulement quand la résolution du modèle change. +struct WebcamMask { + tex: ID3D11Texture2D, + srv: ID3D11ShaderResourceView, + width: u32, + height: u32, +} + pub struct Compositor { dev: ID3D11Device, ctx: ID3D11DeviceContext, @@ -125,6 +146,11 @@ pub struct Compositor { /// Cache des textures wallpaper image (clé = chemin absolu) : décodage/upload une seule /// fois, puis réutilisées par frame. (SRV, largeur, hauteur). img_cache: RefCell>, + /// Masque de segmentation du sujet webcam, R8 à la résolution du modèle. Écrit par + /// `set_webcam_mask` depuis le thread d'inférence, lu au moment de dessiner la webcam. + /// `None` tant qu'aucune frame n'a été segmentée — l'effet reste alors éteint plutôt que + /// de rendre une webcam invisible en mode détourage. + webcam_mask: RefCell>, /// Dimensions du RENDER TARGET en pixels — la taille à laquelle `compose_frame` /// rastérise réellement, et donc le dénominateur de TOUTE conversion /// normalisé↔px de ce fichier. @@ -150,6 +176,21 @@ pub struct Compositor { /// de prévisualisation demandée (variable, contrairement au `staging` fixe à /// OUT_W×OUT_H). Recréée quand la taille change — voir `readback_resized`. live_readback_staging: RefCell>, + /// Cible + staging pour extraire la frame webcam à la résolution du modèle de + /// segmentation. Créée à la première capture, jamais redimensionnée : le modèle a une + /// entrée fixe. + seg_capture: RefCell>, + /// Worker d'inférence, absent tant que `enable_segmentation` n'a pas été appelé. + seg_worker: RefCell>, + /// Boîte aux lettres du worker. Le masque est déposé depuis le thread d'inférence et + /// téléversé depuis le thread de rendu : aucun appel D3D ne traverse de thread, malgré + /// le device multithread-protected qui l'autoriserait. + seg_inbox: std::sync::Arc>>>, + seg_rate: RefCell, + /// Frame RGB réutilisée d'une capture à l'autre. + seg_scratch: RefCell>, + /// Le chargement du modèle a échoué : ne pas réessayer à chaque frame. + seg_failed: RefCell, /// Staging NV12 du readback d'ENCODAGE (backend CPU) — même motif de cache par taille /// que `live_readback_staging`, mais en NV12 et non en RGBA : l'encodeur logiciel veut /// les plans Y/UV, pas des pixels RGBA. Voir `read_nv12_scaled`. @@ -556,9 +597,16 @@ impl Compositor { text_cache: RefCell::new(HashMap::new()), ann_img_cache: RefCell::new(HashMap::new()), img_cache: RefCell::new(HashMap::new()), + webcam_mask: RefCell::new(None), render_size: Cell::new((out_w, out_h)), resize_target: RefCell::new(None), live_readback_staging: RefCell::new(None), + seg_capture: RefCell::new(None), + seg_worker: RefCell::new(None), + seg_inbox: std::sync::Arc::new(std::sync::Mutex::new(None)), + seg_rate: RefCell::new(crate::segmentation::RateLimiter::new(SEGMENTATION_HZ)), + seg_scratch: RefCell::new(Vec::new()), + seg_failed: RefCell::new(false), nv12_readback_staging: RefCell::new(None), }) } @@ -846,6 +894,269 @@ impl Compositor { Ok((srv.unwrap(), w, h)) } + /// Extrait la frame webcam en RGB8 à la résolution du modèle, dans `out`. + /// + /// `src` est le rect source de la webcam en UV (le même que celui passé à `draw_video`), + /// donc le crop utilisateur et le miroir sont déjà dedans — le modèle voit exactement ce + /// que le spectateur verra, et le masque n'a pas à être recadré après coup. + /// + /// **À appeler AVANT `begin()`** : la méthode réquisitionne la cible de rendu et le + /// viewport, et ne les restaure pas. Les appeler dans l'autre ordre dessinerait la scène + /// dans une texture de 256x144. + /// + /// C'est le seul readback GPU->CPU du chemin. Il porte 256x144x4 = 147 Ko, contre la + /// frame entière que la preview lit déjà à chaque image ; sur le chemin export, qui lui + /// est GPU-résident de bout en bout, c'est en revanche un point de synchronisation neuf + /// et c'est là qu'il faudra le mesurer. + pub unsafe fn capture_webcam_rgb( + &self, + wy: &ID3D11ShaderResourceView, + wuv: &ID3D11ShaderResourceView, + src: [f32; 4], + width: u32, + height: u32, + out: &mut Vec, + ) -> Result<()> { + if width == 0 || height == 0 { + bail!("capture webcam de dimensions nulles ({width}x{height})"); + } + { + let mut slot = self.seg_capture.borrow_mut(); + if !matches!(slot.as_ref(), Some(c) if c.width == width && c.height == height) { + let td = D3D11_TEXTURE2D_DESC { + Width: width, + Height: height, + MipLevels: 1, + ArraySize: 1, + Format: DXGI_FORMAT_R8G8B8A8_UNORM, + SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 }, + Usage: D3D11_USAGE_DEFAULT, + BindFlags: D3D11_BIND_RENDER_TARGET.0 as u32, + CPUAccessFlags: 0, + MiscFlags: 0, + }; + let mut rt: Option = None; + self.dev.CreateTexture2D(&td, None, Some(&mut rt))?; + let rt = rt.unwrap(); + let mut rtv: Option = None; + self.dev.CreateRenderTargetView(&rt, None, Some(&mut rtv))?; + + let sd = D3D11_TEXTURE2D_DESC { + Usage: D3D11_USAGE_STAGING, + BindFlags: 0, + CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32, + ..td + }; + let mut staging: Option = None; + self.dev.CreateTexture2D(&sd, None, Some(&mut staging))?; + + *slot = Some(SegCapture { + rtv: rtv.unwrap(), + rt, + staging: staging.unwrap(), + width, + height, + }); + } + } + + let cap = self.seg_capture.borrow(); + let cap = cap.as_ref().expect("créé juste au-dessus"); + + self.bind_compose_state(); + self.ctx.OMSetBlendState(&self.blend_none, None, 0xffffffff); + self.ctx.OMSetRenderTargets(Some(&[Some(cap.rtv.clone())]), None); + let vp = D3D11_VIEWPORT { + TopLeftX: 0.0, TopLeftY: 0.0, + Width: width as f32, Height: height as f32, MinDepth: 0.0, MaxDepth: 1.0, + }; + self.ctx.RSSetViewports(Some(&[vp])); + // Plein cadre de la cible, sans coins ni motion blur : le modèle veut l'image, pas + // la mise en forme. + self.draw_video( + &LayerCB { + dst: [0.0, 0.0, 1.0, 1.0], + src, + quad_px: [width as f32, height as f32], + mode: 0.0, + color: [0.0, 0.0, 0.0, 1.0], + mb: [1.0, 1.0, 1.0, 0.0], + ..Default::default() + }, + wy, + wuv, + ); + + self.ctx.CopyResource(&cap.staging, &cap.rt); + let mut mapped = D3D11_MAPPED_SUBRESOURCE::default(); + self.ctx.Map(&cap.staging, 0, D3D11_MAP_READ, 0, Some(&mut mapped))?; + out.clear(); + out.reserve((width * height * 3) as usize); + for row in 0..height as usize { + let line = (mapped.pData as *const u8).add(row * mapped.RowPitch as usize); + for col in 0..width as usize { + let px = line.add(col * 4); + // RGBA -> RGB : le modèle n'a pas de canal alpha en entrée. + out.push(*px); + out.push(*px.add(1)); + out.push(*px.add(2)); + } + } + self.ctx.Unmap(&cap.staging, 0); + Ok(()) + } + + /// Publie le masque de segmentation du sujet webcam (R8, `width`x`height`, 0 = fond). + /// + /// Appelé depuis le thread d'inférence, pas depuis le thread de rendu — d'où le + /// `SetMultithreadProtected(true)` posé à la création du device (`d3d_windows.rs`). La + /// texture est `DYNAMIC` et réécrite en place ; elle n'est recréée que si la résolution du + /// modèle change, ce qui n'arrive pas en régime établi. + pub fn set_webcam_mask(&self, data: &[u8], width: u32, height: u32) -> Result<()> { + if width == 0 || height == 0 { + bail!("masque webcam de dimensions nulles ({width}x{height})"); + } + let expected = (width as usize) * (height as usize); + if data.len() < expected { + bail!("masque webcam trop court : {} octets pour {width}x{height}", data.len()); + } + + let mut slot = self.webcam_mask.borrow_mut(); + let needs_alloc = !matches!(slot.as_ref(), Some(m) if m.width == width && m.height == height); + if needs_alloc { + let td = D3D11_TEXTURE2D_DESC { + Width: width, + Height: height, + MipLevels: 1, + ArraySize: 1, + Format: DXGI_FORMAT_R8_UNORM, + SampleDesc: DXGI_SAMPLE_DESC { Count: 1, Quality: 0 }, + Usage: D3D11_USAGE_DYNAMIC, + BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32, + CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32, + MiscFlags: 0, + }; + let mut tex: Option = None; + unsafe { self.dev.CreateTexture2D(&td, None, Some(&mut tex))? }; + let tex = tex.unwrap(); + let mut srv: Option = None; + unsafe { self.dev.CreateShaderResourceView(&tex, None, Some(&mut srv))? }; + *slot = Some(WebcamMask { tex, srv: srv.unwrap(), width, height }); + } + + let mask = slot.as_ref().expect("alloué juste au-dessus"); + unsafe { + let mut mapped = D3D11_MAPPED_SUBRESOURCE::default(); + self.ctx.Map(&mask.tex, 0, D3D11_MAP_WRITE_DISCARD, 0, Some(&mut mapped))?; + // `RowPitch` n'est pas `width` : le driver aligne les lignes, donc on recopie + // ligne à ligne plutôt que d'un bloc. + for row in 0..height as usize { + let dst = (mapped.pData as *mut u8).add(row * mapped.RowPitch as usize); + let src = data.as_ptr().add(row * width as usize); + std::ptr::copy_nonoverlapping(src, dst, width as usize); + } + self.ctx.Unmap(&mask.tex, 0); + } + Ok(()) + } + + /// Un tour de segmentation : téléverse le masque prêt, puis soumet une nouvelle frame si + /// la cadence l'autorise. + /// + /// Les deux moitiés sont volontairement désynchronisées. Le masque téléversé ici vient de + /// la frame précédente — une frame de retard sur une silhouette est invisible, alors + /// qu'attendre l'inférence bloquerait le rendu, ce qui est exactement le coût que toute + /// cette conception cherche à ne pas payer. + unsafe fn pump_segmentation( + &self, + wy: &ID3D11ShaderResourceView, + wuv: &ID3D11ShaderResourceView, + valid: [f32; 2], + ) -> Result<()> { + if *self.seg_failed.borrow() { + return Ok(()); + } + // Rien à faire si aucun effet n'est demandé : ni capture, ni inférence, ni masque. + // Le coût de la fonctionnalité est alors exactement nul. + let (wants_effect, model_path) = { + let scene = self.scene.borrow(); + match scene.as_ref().and_then(|s| s.webcam_effect.as_ref()) { + Some(e) if e.shader_code() > 0.0 => (true, e.model_path.clone()), + _ => (false, None), + } + }; + if !wants_effect { + return Ok(()); + } + + // Démarrage paresseux, piloté par la scène : personne n'a à appeler + // `enable_segmentation` à la main, et un modèle introuvable éteint l'effet au lieu + // de faire tomber le rendu. + if self.seg_worker.borrow().is_none() { + let Some(path) = model_path else { return Ok(()) }; + if let Err(e) = self.enable_segmentation(std::path::Path::new(&path)) { + eprintln!("[segmentation] désactivée : {e}"); + // Une scène qui reste identique retenterait à chaque frame ; on pose un + // worker vide plutôt que de journaliser 60 fois par seconde. + *self.seg_failed.borrow_mut() = true; + } + return Ok(()); + } + + if let Some(mask) = self.seg_inbox.lock().unwrap().take() { + self.set_webcam_mask( + &mask, + crate::segmentation::MODEL_WIDTH, + crate::segmentation::MODEL_HEIGHT, + )?; + } + + if !self.seg_rate.borrow_mut().should_run(std::time::Instant::now()) { + return Ok(()); + } + let mut scratch = self.seg_scratch.borrow_mut(); + // La frame ENTIÈRE, pas le sous-rect dessiné : un crop utilisateur serré amputerait + // le sujet en entrée du modèle, et le masque serait faux là où il compte le plus. + // Le shader ramène ses coordonnées dans cet espace via `fx.xy`. + self.capture_webcam_rgb( + wy, + wuv, + [0.0, 0.0, valid[0], valid[1]], + crate::segmentation::MODEL_WIDTH, + crate::segmentation::MODEL_HEIGHT, + &mut scratch, + )?; + if let Some(w) = self.seg_worker.borrow().as_ref() { + w.submit(&scratch); + } + Ok(()) + } + + /// Démarre la segmentation du sujet webcam pour ce compositeur. + /// + /// Idempotent. Tant qu'elle n'est pas appelée, `compose_frame` ne fait rien de plus et + /// la webcam se dessine comme avant — c'est ce qui rend l'effet inerte plutôt que cassé + /// sur une build sans modèle. + pub fn enable_segmentation(&self, model_path: &std::path::Path) -> Result<()> { + if self.seg_worker.borrow().is_some() { + return Ok(()); + } + let segmenter = crate::segmentation::Segmenter::load(model_path)?; + let inbox = std::sync::Arc::clone(&self.seg_inbox); + let worker = crate::segmentation::SegmentationWorker::spawn(segmenter, move |mask, _, _| { + // Écrase le masque précédent s'il n'a pas encore été téléversé : c'est le plus + // récent qui vaut, jamais une file. + *inbox.lock().unwrap() = Some(mask.to_vec()); + }); + *self.seg_worker.borrow_mut() = Some(worker); + Ok(()) + } + + /// Éteint l'effet : la webcam se redessine telle quelle à la frame suivante. + pub fn clear_webcam_mask(&self) { + *self.webcam_mask.borrow_mut() = None; + } + pub fn set_cursor(&self, track: CursorTrack) { *self.cursor.borrow_mut() = Some(track); } @@ -1097,6 +1408,12 @@ impl Compositor { let (wtw, wth) = self.tex_dims(webcam); let (scw, sch) = ((*screen).width as f32, (*screen).height as f32); let (wcw, wch) = ((*webcam).width as f32, (*webcam).height as f32); + // Étendue valide de la texture webcam : les décodeurs allouent des textures alignées, + // donc la frame n'occupe pas forcément toute la texture. + let w_valid = [wcw / wtw as f32, wch / wth as f32]; + + // Segmentation, AVANT `begin()` : la capture réquisitionne la cible de rendu. + self.pump_segmentation(&wy, &wuv, w_valid)?; let u_max = scw / stw as f32; let v_max = sch / sth as f32; @@ -1538,7 +1855,13 @@ impl Compositor { scene_preset.as_deref(), Some("dual-frame") | Some("vertical-stack"), ); - if cfg.shadow && !webcam_is_block && shape_fade > 0.0 { + // L'ombre appartient à la bulle PiP. En détourage il n'y a plus de bulle — une + // ombre portée par un rectangle invisible se lit comme un artefact. + let is_cutout = matches!( + scene_ref.as_ref().and_then(|s| s.webcam_effect.as_ref()), + Some(e) if e.shader_code() == 1.0 + ) && self.webcam_mask.borrow().is_some(); + if cfg.shadow && !webcam_is_block && !is_cutout && shape_fade > 0.0 { let strength = WEBCAM_SHADOW_OPACITY * shape_fade; self.draw_shadow( w_dst, @@ -1549,6 +1872,41 @@ impl Compositor { strength, ); } + // Effet d'arrière-plan : le mode vient de la scène, le masque par pixel de + // l'inférence. Les DEUX sont requis — un mode sans masque rendrait la webcam + // invisible en détourage, donc tant que rien n'a été segmenté on dessine la piste + // telle quelle. C'est aussi ce qui rend le premier lancement gracieux. + let mask = self.webcam_mask.borrow(); + let effect = scene_ref + .as_ref() + .and_then(|s| s.webcam_effect.as_ref()) + .filter(|_| mask.is_some()) + .map(|e| (e.shader_code(), e)) + .filter(|(code, _)| *code > 0.0); + + let (effect_code, blur_intensity, bg_color) = match effect { + Some((code, e)) if code > 2.5 => { + // Fond personnalisé : seule une couleur plate se peint dans le shader. Un + // dégradé ou une image passeraient par une texture, ce que ce calque ne + // porte pas encore — on retombe alors sur du noir plutôt que sur du hasard. + let col = match &e.background { + Some(SceneBackground::Color { color }) => { + parse_hex(color).unwrap_or([0.0, 0.0, 0.0, 1.0]) + } + _ => [0.0, 0.0, 0.0, 1.0], + }; + (code, 0.0, col) + } + Some((code, e)) => (code, e.blur_intensity.clamp(0.0, 1.0), [0.0, 0.0, 0.0, 1.0]), + None => (0.0, 0.0, [0.0, 0.0, 0.0, 1.0]), + }; + + if let Some(m) = mask.as_ref() { + // `draw_video` ne lie que les slots 0-1, donc le masque posé ici tient pour + // l'appel qui suit. Il est délié juste après pour ne pas fuir sur les calques + // d'annotation, qui utilisent eux aussi le slot 2 et au-delà. + self.ctx.PSSetShaderResources(3, Some(&[Some(m.srv.clone())])); + } self.draw_video( &LayerCB { dst: w_dst, @@ -1556,7 +1914,8 @@ impl Compositor { quad_px: w_px, radius_px: w_radius, mode: 0.0, - color: [0.0, 0.0, 0.0, 1.0], + color: bg_color, + fx: [w_valid[0], w_valid[1], effect_code, blur_intensity], src_prev: [u0, sv0, u1, sv1], // src fixe (pas de zoom webcam) dst_prev: w_dst_prev, mb: [mb_taps, 1.0, 1.0, 0.0], @@ -1565,6 +1924,9 @@ impl Compositor { &wy, &wuv, ); + if mask.is_some() { + self.ctx.PSSetShaderResources(3, Some(&[None])); + } } // --- annotations : calque le plus haut, comme dans le DOM de la preview (le calque y est diff --git a/crates/compositor/src/lib.rs b/crates/compositor/src/lib.rs index d8972e7d1..90dee8155 100644 --- a/crates/compositor/src/lib.rs +++ b/crates/compositor/src/lib.rs @@ -40,6 +40,10 @@ pub mod regions; // n'est spécifique à Linux. pub mod remux; pub mod scene; +// Segmentation du sujet webcam (masque -> `t3`). Le module compile toujours ; sans la feature +// `segmentation` ses deux entrées échouent proprement, ce qui garde le reste du crate +// indépendant du choix de packaging d'ONNX Runtime. +pub mod segmentation; pub mod text_anim; pub mod text_plate; pub(crate) mod timeline_walk; diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs index 2d20e233b..b6fb420c0 100644 --- a/crates/compositor/src/scene.rs +++ b/crates/compositor/src/scene.rs @@ -429,6 +429,43 @@ pub struct SceneOutput { pub fps: Option, } +/// Effet d'arrière-plan de la webcam. +/// +/// Ne porte que le MODE et ses paramètres — jamais des pixels. Le masque par pixel vient de +/// la segmentation qui tourne dans ce processus (`segmentation.rs`) et arrive au shader comme +/// texture `t3`. Une version antérieure faisait cuire le composite côté app et l'envoyait +/// comme piste vidéo : le codec ne sait pas porter l'alpha, et preview et export divergeaient. +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct SceneWebcamEffect { + /// "none" | "transparent" | "blur" | "custom" + pub mode: String, + /// 0..1, seulement pour `blur`. + #[serde(default)] + pub blur_intensity: f32, + /// Fond derrière le sujet pour `custom`, parsé comme `settings.wallpaper`. + #[serde(default)] + pub background: Option, + /// Chemin du modèle ONNX de segmentation. Même convention que `SceneCursorSprite::path` + /// ou qu'un wallpaper image : c'est l'app qui sait où ses assets sont installés, le + /// natif ne devine pas. Absent = pas de segmentation, l'effet reste éteint. + #[serde(default)] + pub model_path: Option, +} + +impl SceneWebcamEffect { + /// Code passé au shader dans `fx.z` : 0 = aucun (la webcam se dessine telle quelle), + /// 1 = détourage, 2 = flou, 3 = fond personnalisé. + pub(crate) fn shader_code(&self) -> f32 { + match self.mode.as_str() { + "transparent" => 1.0, + "blur" => 2.0, + "custom" => 3.0, + _ => 0.0, + } + } +} + /// Tout ce dont le natif a besoin pour composer la scène, sérialisé depuis un document. #[derive(Debug, Clone, Deserialize)] #[serde(rename_all = "camelCase")] @@ -454,6 +491,9 @@ pub struct Scene { /// Crop écran par clip, dans le même ordre que `clips` (`cropByClip` côté TS). #[serde(default)] pub crop_by_clip: Vec>, + /// Effet d'arrière-plan de la webcam. Absent = aucun effet. + #[serde(default)] + pub webcam_effect: Option, /// État de rendu interne, positionné par `for_clip_window` (jamais envoyé par l'app). #[serde(skip)] pub(crate) active_clip_index: usize, @@ -601,6 +641,37 @@ mod tests { let s = Scene::from_json(json).expect("parse sans webcam_rect"); assert!(s.layout.webcam_rect.is_none()); assert_eq!(s.layout.preset, "picture-in-picture"); + assert!(s.webcam_effect.is_none()); + } + + #[test] + fn webcam_effect_maps_each_mode_to_its_shader_code() { + let scene_with = |effect: &str| { + let json = format!( + r##"{{"clips":[],"layout":{{"preset":"picture-in-picture","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false}},"effects":{{"padding":0,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0}},"background":{{"kind":"color","color":"#000000"}},"zoomRegions":[],"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}},"cropByClip":[],"output":{{"width":1920,"height":1080,"fps":null}},"webcamEffect":{}}}"##, + effect + ); + Scene::from_json(&json).expect("parse avec webcamEffect").webcam_effect.expect("présent") + }; + + assert_eq!(scene_with(r#"{"mode":"none"}"#).shader_code(), 0.0); + assert_eq!(scene_with(r#"{"mode":"transparent"}"#).shader_code(), 1.0); + assert_eq!(scene_with(r#"{"mode":"blur","blurIntensity":0.75}"#).shader_code(), 2.0); + assert_eq!(scene_with(r#"{"mode":"custom"}"#).shader_code(), 3.0); + // Un mode inconnu (document trafiqué, schéma futur) ne doit pas allumer un effet. + assert_eq!(scene_with(r#"{"mode":"hologram"}"#).shader_code(), 0.0); + + let blur = scene_with(r#"{"mode":"blur","blurIntensity":0.75}"#); + assert_eq!(blur.blur_intensity, 0.75); + // `blurIntensity` absent => 0, pas une erreur de parse. + assert_eq!(scene_with(r#"{"mode":"blur"}"#).blur_intensity, 0.0); + + let custom = + scene_with(r##"{"mode":"custom","background":{"kind":"color","color":"#ff0080"}}"##); + match custom.background { + Some(SceneBackground::Color { color }) => assert_eq!(color, "#ff0080"), + other => panic!("attendu un fond couleur, obtenu {other:?}"), + } } } diff --git a/crates/compositor/src/segmentation.rs b/crates/compositor/src/segmentation.rs new file mode 100644 index 000000000..92b88d3fc --- /dev/null +++ b/crates/compositor/src/segmentation.rs @@ -0,0 +1,352 @@ +//! Segmentation du sujet webcam — le masque que `ps_main` consomme en `t3`. +//! +//! # Pourquoi l'EP CPU et pas le GPU +//! +//! Mesuré sur la cible (Radeon 610M intégré, cf. +//! `technical-documentation/engineering/webcam-segmentation.md`) : l'EP CPU coûte **+0,47 ms +//! par frame** au compositeur contre **+1,03 ms** pour DirectML, et — le point qui décide — +//! son coût **ne dépend pas de la résolution d'entrée**, là où celui de DirectML suit les +//! pixels. L'EP CPU à pleine résolution est donc moins cher que DirectML ne l'est jamais, +//! même à résolution réduite. +//! +//! Le vrai gain n'est pas la marge, il est architectural : pas de DirectML ⇒ pas de device +//! D3D12, pas de handle partagé, pas d'appariement de LUID d'adaptateur, pas de fence +//! inter-queue, et un seul chemin sur les trois plateformes au lieu de trois. +//! +//! # Le piège du nombre de threads +//! +//! Une session ONNX Runtime laissée par défaut prend tous les cœurs. Sur la machine de +//! mesure (4 cœurs) ça donne un **p95 de 24,9 ms** — une frame perdue à chaque fois que ça +//! tombe. `intra_op_num_threads = 2` est à 8 % du meilleur p10 avec moins de la moitié de la +//! traîne, et laisse deux cœurs au compositeur. La bonne valeur n'était pas la plus rapide. + +use anyhow::{bail, Result}; +use std::path::Path; +use std::sync::{Arc, Condvar, Mutex}; +use std::time::{Duration, Instant}; + +/// Résolution d'entrée du modèle vendorisé (`selfie_segmentation_landscape.onnx`). +/// +/// Le graphe est entièrement convolutif, donc réductible — mais mesuré, ça ne sert à rien : +/// le coût de l'EP CPU est plat en résolution. Et 128x80 n'est pas livrable, la caméra en +/// plein écran agrandit le masque ~15x et les cheveux s'effondrent en rampe. +pub const MODEL_WIDTH: u32 = 256; +pub const MODEL_HEIGHT: u32 = 144; + +/// Deux threads intra-op. Voir la note du module : le défaut prend toute la machine. +const INTRA_OP_THREADS: usize = 2; + +/// Segmenteur chargé, prêt à produire un masque par frame. +pub struct Segmenter { + #[cfg(feature = "segmentation")] + session: ort::session::Session, + /// Réutilisé d'une frame à l'autre pour ne pas réallouer 110 Ko à 30 Hz. + input_scratch: Vec, + mask_scratch: Vec, +} + +impl Segmenter { + /// Charge le modèle ONNX. `model_path` est le `.onnx` vendorisé à côté des `.tflite`. + #[cfg(feature = "segmentation")] + pub fn load(model_path: &Path) -> Result { + if !model_path.exists() { + bail!("modèle de segmentation absent : {}", model_path.display()); + } + // `ort::Error` est générique sur le type du builder, donc il ne satisfait pas les + // bornes d'`anyhow::Context` — d'où le `map_err` explicite plutôt qu'un `?` direct. + let session = (|| -> ort::Result { + ort::session::Session::builder()? + .with_intra_threads(INTRA_OP_THREADS)? + // Un seul thread inter-op : le graphe est une chaîne, il n'y a rien à + // paralléliser entre branches, et un pool de plus ne ferait que disputer les + // cœurs au compositeur. + .with_inter_threads(1)? + .commit_from_file(model_path) + })() + .map_err(|e| anyhow::anyhow!("chargement de {} : {e}", model_path.display()))?; + Ok(Self { + session, + input_scratch: vec![0.0; (MODEL_WIDTH * MODEL_HEIGHT * 3) as usize], + mask_scratch: vec![0; (MODEL_WIDTH * MODEL_HEIGHT) as usize], + }) + } + + #[cfg(not(feature = "segmentation"))] + pub fn load(_model_path: &Path) -> Result { + bail!("compilé sans la feature `segmentation`") + } + + /// Produit le masque du sujet à partir d'une frame RGB8 déjà mise à l'échelle du modèle. + /// + /// `rgb` fait `MODEL_WIDTH * MODEL_HEIGHT * 3` octets, entrelacé R,G,B. Le retour fait + /// `MODEL_WIDTH * MODEL_HEIGHT` octets, 0 = fond, 255 = sujet — exactement ce que + /// `Compositor::set_webcam_mask` attend. + /// + /// Le redimensionnement n'est pas fait ici : l'appelant a déjà la frame sur le GPU et sait + /// la réduire bien mieux qu'une boucle CPU. + #[cfg(feature = "segmentation")] + pub fn run(&mut self, rgb: &[u8]) -> Result<&[u8]> { + let expected = (MODEL_WIDTH * MODEL_HEIGHT * 3) as usize; + if rgb.len() != expected { + bail!("frame de {} octets, {expected} attendus", rgb.len()); + } + // Le modèle veut du 0..1 en NHWC — le même ordre que la frame entrelacée, donc une + // simple division sans transposition. + for (dst, &src) in self.input_scratch.iter_mut().zip(rgb.iter()) { + *dst = src as f32 * (1.0 / 255.0); + } + + // `TensorRef` emprunte le scratch au lieu de le copier : à 30 Hz, 442 Ko recopiés par + // frame pour rien seraient exactement le genre de coût que cette conception évite. + let shape = [1_i64, MODEL_HEIGHT as i64, MODEL_WIDTH as i64, 3]; + let input = ort::value::TensorRef::from_array_view((shape, self.input_scratch.as_slice())) + .map_err(|e| anyhow::anyhow!("construction du tenseur d'entrée : {e}"))?; + let outputs = self + .session + .run(ort::inputs!["input_1" => input]) + .map_err(|e| anyhow::anyhow!("inférence : {e}"))?; + let (_, mask) = outputs["segment_back"] + .try_extract_tensor::() + .map_err(|e| anyhow::anyhow!("extraction du masque : {e}"))?; + + if mask.len() != self.mask_scratch.len() { + bail!("masque de {} valeurs, {} attendues", mask.len(), self.mask_scratch.len()); + } + // Déjà passé par une sigmoïde dans le graphe, donc borné 0..1 — le clamp ne protège + // que d'un modèle regénéré différemment. + for (dst, &src) in self.mask_scratch.iter_mut().zip(mask.iter()) { + *dst = (src.clamp(0.0, 1.0) * 255.0) as u8; + } + Ok(&self.mask_scratch) + } + + #[cfg(not(feature = "segmentation"))] + pub fn run(&mut self, _rgb: &[u8]) -> Result<&[u8]> { + bail!("compilé sans la feature `segmentation`") + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// Le chemin par défaut du modèle vendorisé, depuis la racine du dépôt. + fn vendored_model() -> std::path::PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.onnx") + } + + #[test] + fn the_vendored_model_is_where_the_loader_expects_it() { + // Ne charge pas le modèle (la feature peut être éteinte) : vérifie seulement que le + // fichier que `load` ira chercher existe et n'est pas un pointeur LFS ou un tronçon. + let path = vendored_model(); + let meta = std::fs::metadata(&path) + .unwrap_or_else(|e| panic!("modèle introuvable en {} : {e}", path.display())); + assert!(meta.len() > 100_000, "modèle suspicieusement petit : {} octets", meta.len()); + } + + // Sans la feature, `load` échoue en disant que la feature manque — un message utile lui + // aussi, mais pas celui-ci. + #[cfg(feature = "segmentation")] + #[test] + fn a_missing_model_fails_with_the_path_in_the_message() { + // `.err()` plutôt que `.unwrap_err()` : ce dernier exigerait `Debug` sur `Segmenter`, + // qui contient une session ONNX Runtime. + let err = match Segmenter::load(Path::new("nexiste/pas.onnx")) { + Ok(_) => panic!("un modèle inexistant ne doit pas charger"), + Err(e) => e.to_string(), + }; + assert!(err.contains("nexiste"), "message peu utile : {err}"); + } + + #[cfg(feature = "segmentation")] + #[test] + fn a_frame_of_the_wrong_size_is_refused_rather_than_read_out_of_bounds() { + let mut seg = Segmenter::load(&vendored_model()).expect("chargement du modèle"); + let err = seg.run(&[0u8; 12]).unwrap_err().to_string(); + assert!(err.contains("attendus"), "message peu utile : {err}"); + } + + #[test] + fn the_rate_limiter_admits_one_frame_per_interval() { + let mut rl = RateLimiter::new(30); + let t0 = Instant::now(); + assert!(rl.should_run(t0), "la première frame passe toujours"); + assert!(!rl.should_run(t0 + Duration::from_millis(10)), "10 ms < 33 ms"); + assert!(!rl.should_run(t0 + Duration::from_millis(33)), "juste sous l'intervalle"); + assert!(rl.should_run(t0 + Duration::from_millis(34)), "au-delà de l'intervalle"); + // Le pas repart du dernier passage accepté, pas du premier : sinon la cadence + // dériverait vers le haut après chaque frame refusée. + assert!(!rl.should_run(t0 + Duration::from_millis(40))); + assert!(rl.should_run(t0 + Duration::from_millis(68))); + } + + #[test] + fn a_60_hz_render_loop_yields_about_30_inferences_per_second() { + let mut rl = RateLimiter::new(30); + let t0 = Instant::now(); + let admitted = (0..60) + .filter(|i| rl.should_run(t0 + Duration::from_micros(16_667 * i))) + .count(); + assert_eq!(admitted, 30, "60 frames rendues doivent donner 30 inférences"); + } + + #[cfg(feature = "segmentation")] + #[test] + fn the_worker_drops_stale_frames_rather_than_queueing_them() { + use std::sync::atomic::{AtomicUsize, Ordering}; + + let seen = Arc::new(AtomicUsize::new(0)); + let counter = Arc::clone(&seen); + let worker = SegmentationWorker::spawn( + Segmenter::load(&vendored_model()).expect("chargement du modèle"), + move |mask, w, h| { + assert_eq!(mask.len(), (w * h) as usize); + counter.fetch_add(1, Ordering::SeqCst); + }, + ); + + // Cent frames déposées d'affilée : le worker en traite bien moins que cent, puisque + // chaque dépôt écrase le précédent non consommé. La borne est large — le test pin le + // fait qu'on écrase, pas un débit. + let frame = vec![90u8; (MODEL_WIDTH * MODEL_HEIGHT * 3) as usize]; + for _ in 0..100 { + worker.submit(&frame); + } + std::thread::sleep(Duration::from_millis(300)); + let done = seen.load(Ordering::SeqCst); + assert!(done > 0, "le worker n'a rien traité"); + assert!(done < 100, "{done} inférences pour 100 dépôts : la file s'accumule"); + } + + #[cfg(feature = "segmentation")] + #[test] + fn segments_a_uniform_frame_without_panicking_and_returns_the_right_size() { + let mut seg = Segmenter::load(&vendored_model()).expect("chargement du modèle"); + let frame = vec![128u8; (MODEL_WIDTH * MODEL_HEIGHT * 3) as usize]; + let mask = seg.run(&frame).expect("inférence"); + assert_eq!(mask.len(), (MODEL_WIDTH * MODEL_HEIGHT) as usize); + // Un gris uniforme ne contient pas de sujet : le masque doit être massivement du + // fond. C'est une borne large, pas une assertion de qualité — elle attrape un modèle + // qui renverrait du bruit ou du plein. + let subject = mask.iter().filter(|&&v| v > 128).count(); + assert!( + subject * 10 < mask.len(), + "{subject} pixels sujet sur {} pour une image unie", + mask.len() + ); + } +} + +/// Cadence l'inférence : 30 Hz, pas la fréquence de rendu. +/// +/// Une silhouette ne change pas de façon perceptible en 16 ms, et c'est le seul levier +/// mesuré qui divise le coût par deux sans toucher au modèle ni à sa précision. Le chemin +/// export tourne déjà à 30 Hz. +pub struct RateLimiter { + interval: Duration, + last: Option, +} + +impl RateLimiter { + pub fn new(hz: u32) -> Self { + Self { interval: Duration::from_secs_f64(1.0 / hz.max(1) as f64), last: None } + } + + /// `true` si assez de temps s'est écoulé depuis le dernier passage. Prend `now` en + /// paramètre plutôt que de lire l'horloge : c'est ce qui rend la cadence testable. + pub fn should_run(&mut self, now: Instant) -> bool { + match self.last { + Some(prev) if now.duration_since(prev) < self.interval => false, + _ => { + self.last = Some(now); + true + } + } + } +} + +/// Boîte d'échange à une place, qui écrase au lieu d'empiler. +/// +/// Si l'inférence prend du retard, la bonne réponse est de sauter des frames, pas d'en +/// accumuler : un masque en retard de trois frames est pire qu'un masque sauté, et une file +/// qui grandit finit par manger la mémoire. `submit` remplace donc silencieusement une frame +/// non consommée. +struct Slot { + frame: Mutex>>, + ready: Condvar, + stop: Mutex, +} + +/// Thread d'inférence : reçoit des frames RGB, publie des masques via un callback. +/// +/// Le callback est appelé depuis le thread du worker, pas depuis celui du rendu — c'est +/// `Compositor::set_webcam_mask` qui est prévu pour ça, le device étant multithread-protected. +pub struct SegmentationWorker { + slot: Arc, + handle: Option>, +} + +impl SegmentationWorker { + /// Démarre le worker. `on_mask` reçoit le masque et ses dimensions à chaque inférence. + pub fn spawn( + mut segmenter: Segmenter, + on_mask: impl Fn(&[u8], u32, u32) + Send + 'static, + ) -> Self { + let slot = Arc::new(Slot { + frame: Mutex::new(None), + ready: Condvar::new(), + stop: Mutex::new(false), + }); + let worker_slot = Arc::clone(&slot); + let handle = std::thread::Builder::new() + .name("openscreen-segmentation".into()) + .spawn(move || loop { + let frame = { + let mut guard = worker_slot.frame.lock().unwrap(); + while guard.is_none() { + if *worker_slot.stop.lock().unwrap() { + return; + } + let (g, timeout) = worker_slot + .ready + .wait_timeout(guard, Duration::from_millis(100)) + .unwrap(); + guard = g; + if timeout.timed_out() && guard.is_none() { + if *worker_slot.stop.lock().unwrap() { + return; + } + } + } + guard.take().expect("non vide, la boucle vient de le vérifier") + }; + match segmenter.run(&frame) { + Ok(mask) => on_mask(mask, MODEL_WIDTH, MODEL_HEIGHT), + // Une frame ratée est sautée, pas fatale : le masque précédent reste + // affiché, ce qui vaut mieux qu'un effet qui clignote. + Err(e) => eprintln!("[segmentation] frame ignorée : {e}"), + } + }) + .expect("le thread de segmentation doit démarrer"); + Self { slot, handle: Some(handle) } + } + + /// Dépose une frame à segmenter. Écrase celle qui attendait, s'il y en avait une. + pub fn submit(&self, rgb: &[u8]) { + let mut guard = self.slot.frame.lock().unwrap(); + *guard = Some(rgb.to_vec()); + self.slot.ready.notify_one(); + } +} + +impl Drop for SegmentationWorker { + fn drop(&mut self) { + *self.slot.stop.lock().unwrap() = true; + self.slot.ready.notify_all(); + if let Some(h) = self.handle.take() { + let _ = h.join(); + } + } +} diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlsl index b9d438d7d..a507abb64 100644 --- a/crates/compositor/src/shaders.hlsl +++ b/crates/compositor/src/shaders.hlsl @@ -39,6 +39,10 @@ VSOut vs_main(uint vid : SV_VertexID) Texture2D texY : register(t0); Texture2D texUV : register(t1); Texture2D texImg : register(t2); // wallpaper image RGBA (fond, mode 6) +// Masque de segmentation du sujet, 0 = fond, 1 = sujet. Produit par `segmentation.rs` a la +// resolution du modele (256x144) ; l'upscale vers la resolution webcam est fait par le sampler +// lineaire, ce qui est exactement le filtrage qu'on veut sur un masque. +Texture2D texMask : register(t3); SamplerState samp : register(s0); // BT.709 limited -> RGB (§7 E1), matrice en dur, range mesuré en S1. @@ -154,6 +158,26 @@ float3 quad_inverse_bilinear(float2 P, float2 c00, float2 c10, float2 c11, float return (r0.z > 0.5) ? r0 : r1; } +// Fond floute pour le mode "blur" de la webcam. Rayon en UV pour rester isotrope quel que soit +// le rect source. 25 taps ponderes par la distance : assez doux pour un fond, assez court pour +// tenir dans le budget d'une frame webcam (qui n'occupe qu'une fraction de la sortie). +float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx) +{ + float2 step = (max(intensity, 0.0) * 12.0 + 2.0) / max(qpx, 1.0); + float3 sum = 0.0; + float total = 0.0; + [unroll] for (int dy = -2; dy <= 2; dy++) + { + [unroll] for (int dx = -2; dx <= 2; dx++) + { + float w = 1.0 / (1.0 + length(float2(dx, dy))); + sum += sample_yuv(saturate(uv + float2(dx, dy) * step)) * w; + total += w; + } + } + return sum / max(total, 1e-4); +} + float4 ps_main(VSOut i) : SV_Target { // mode 13 : SPRITE DE CURSEUR posé sur l'écran incliné. Même warp que le mode 8, mais @@ -410,6 +434,8 @@ float4 ps_main(VSOut i) : SV_Target } float3 rgb; + // 1 sauf en mode detourage, ou il porte le masque du sujet (cf. la branche fx.z ci-dessous). + float alpha_mask = 1.0; if (mode < 0.5) { // flou de mouvement par vélocité (§8) : pour CE pixel sortie, uv à la frame @@ -435,13 +461,41 @@ float4 ps_main(VSOut i) : SV_Target } rgb = acc / (float) taps; } + + // Effet d'arriere-plan webcam. fx.z : 1 = detourage, 2 = flou, 3 = fond personnalise. + // `color` porte la couleur de fond du mode 3, fx.w l'intensite du flou du mode 2. + // fx.xy porte l'etendue VALIDE de la texture webcam (wcw/wtw, wch/wth) : le masque a + // ete produit sur la frame ENTIERE, pas sur le sous-rect dessine, pour que le modele + // ne se fasse pas amputer le sujet par un crop utilisateur. Il faut donc ramener uv, + // qui vit dans l'espace source, dans cet espace-la. + // Le masque est absent (texture 1x1 noire) tant que la segmentation n'a pas produit sa + // premiere frame : `person` vaut alors 0 et le mode 1 rendrait la webcam invisible, donc + // c'est l'appelant qui ne met fx.z a autre chose que 0 qu'une fois un masque disponible. + float effect = fx.z; + if (effect > 0.5) + { + float2 mask_uv = uv_now / max(fx.xy, 1e-6); + float person = saturate(texMask.Sample(samp, mask_uv)); + if (effect > 2.5) + { + rgb = lerp(color.rgb, rgb, person); + } + else if (effect > 1.5) + { + rgb = lerp(blur_webcam_bg(uv_now, fx.w, quad_px), rgb, person); + } + else + { + alpha_mask = person; + } + } } else { rgb = color.rgb; } - float alpha = color.a; + float alpha = color.a * alpha_mask; if (radius_px > 0.0) { // `quad_px` est en px de SORTIE (le render target porte la géométrie de sortie) et diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts index 4eb288e14..bfb8e535d 100644 --- a/electron/electron-env.d.ts +++ b/electron/electron-env.d.ts @@ -95,6 +95,15 @@ interface Window { message?: string; error?: string; }>; + writeDerivedMedia: ( + data: ArrayBuffer, + fileName: string, + ) => Promise<{ + success: boolean; + path?: string; + message?: string; + error?: string; + }>; storeRecordedSession: ( payload: import("../src/lib/recordingSession").StoreRecordedSessionInput, ) => Promise<{ diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts index 958ef6d96..7eb3993bb 100644 --- a/electron/ipc/handlers.ts +++ b/electron/ipc/handlers.ts @@ -104,6 +104,12 @@ const ALLOWED_IMPORT_VIDEO_EXTENSIONS = new Set([ ".ts", ]); const PREVIEW_AUDIO_DIR = path.join(app.getPath("userData"), "preview-audio"); +// Derived export artifacts (pre-segmented webcam tracks, …). Deliberately NOT +// RECORDINGS_DIR: these are regenerable byproducts of one export run, not takes, +// and `get-recorded-video-path` returns the alphabetically last `.webm` in there — +// a `webcam-segmented-*.webm` would sort after `recording-*` and be handed back as +// "the latest recording". +const DERIVED_MEDIA_DIR = path.join(app.getPath("userData"), "derived-media"); const nativeMacCaptureEvents = new EventEmitter(); // Enumeration walks every display and window and grabs a thumbnail of each, so it @@ -3411,6 +3417,54 @@ export function registerIpcHandlers( } }); + // A derived export artifact, NOT a take: no recording-session state, no + // `.session.json` manifest, no media links, no cursor-telemetry flush. + // `store-recorded-video` does all of that (it is the session finaliser) and is + // the wrong door for a file an export regenerates every run. + ipcMain.handle("write-derived-media", async (_, data: ArrayBuffer, fileName: string) => { + try { + const trimmed = typeof fileName === "string" ? fileName.trim() : ""; + if (!trimmed) { + return { success: false, message: "Invalid derived media file name" }; + } + // `base` differs from the input for `a/b`, `a\b` and absolute paths — but NOT + // for "." or "..", which `path.join` would then resolve back out of the + // directory. `resolveRecordingOutputPath` rejects those explicitly; so does this. + const parsedName = path.parse(trimmed); + if ( + parsedName.base !== trimmed || + path.isAbsolute(trimmed) || + trimmed === "." || + trimmed === ".." + ) { + return { + success: false, + message: "Derived media file name must not contain path segments", + }; + } + + await fs.mkdir(DERIVED_MEDIA_DIR, { recursive: true }); + const outputPath = path.join(DERIVED_MEDIA_DIR, parsedName.base); + await fs.writeFile(outputPath, Buffer.from(data)); + // The file lives outside RECORDINGS_DIR, so the read gate would refuse it. + // We just wrote it, so it is approved by construction. + approveFilePath(outputPath); + + return { + success: true, + path: outputPath, + message: "Derived media written successfully", + }; + } catch (error) { + console.error("Failed to write derived media:", error); + return { + success: false, + message: "Failed to write derived media", + error: String(error), + }; + } + }); + ipcMain.handle("get-recorded-video-path", async () => { try { if (currentRecordingSession?.screenVideoPath) { diff --git a/electron/preload.ts b/electron/preload.ts index 6aff16407..37da9590c 100644 --- a/electron/preload.ts +++ b/electron/preload.ts @@ -159,6 +159,11 @@ contextBridge.exposeInMainWorld("electronAPI", { storeRecordedVideo: (videoData: ArrayBuffer, fileName: string) => { return ipcRenderer.invoke("store-recorded-video", videoData, fileName); }, + /** Derived export artifact (pre-segmented webcam track, …) → userData/derived-media. + * Unlike storeRecordedVideo this touches no recording-session state. */ + writeDerivedMedia: (data: ArrayBuffer, fileName: string) => { + return ipcRenderer.invoke("write-derived-media", data, fileName); + }, storeRecordedSession: (payload: StoreRecordedSessionInput) => { return ipcRenderer.invoke("store-recorded-session", payload); }, diff --git a/nix/package.nix b/nix/package.nix index 9e5dd1e23..02e9eb10a 100644 --- a/nix/package.nix +++ b/nix/package.nix @@ -51,7 +51,7 @@ buildNpmPackage { ); }; - npmDepsHash = "sha256-Vr6Sw/WKmX22eT4a22+Xr3/miMzZr2uAwiYx12toU/E="; + npmDepsHash = "sha256-LkKX1edTPHZq5nQRrbLAn11oVw36kb0smNQMmVRMEPA="; env.ELECTRON_SKIP_BINARY_DOWNLOAD = "1"; diff --git a/package-lock.json b/package-lock.json index e0ea6e09c..e1322c336 100644 --- a/package-lock.json +++ b/package-lock.json @@ -13,6 +13,7 @@ "@langchain/core": "^1.1.44", "@langchain/mistralai": "^1.0.8", "@langchain/openai": "^1.4.2", + "@mediapipe/selfie_segmentation": "^0.1.1675465747", "@radix-ui/react-accordion": "^1.2.12", "@radix-ui/react-dialog": "^1.1.15", "@radix-ui/react-dropdown-menu": "^2.1.16", @@ -2141,6 +2142,12 @@ "node": ">= 10.0.0" } }, + "node_modules/@mediapipe/selfie_segmentation": { + "version": "0.1.1675465747", + "resolved": "https://registry.npmjs.org/@mediapipe/selfie_segmentation/-/selfie_segmentation-0.1.1675465747.tgz", + "integrity": "sha512-IxYxNhwE5VwOm52L1yoFWYLP7q9Pd+NJjzOC5tlepfvEGaY3o9hslhUrx9BgseqdfZtKSDtd/4NfCSMjNzQalA==", + "license": "Apache-2.0" + }, "node_modules/@mistralai/mistralai": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/@mistralai/mistralai/-/mistralai-2.2.1.tgz", diff --git a/package.json b/package.json index 412f6dfb2..ed78f5641 100644 --- a/package.json +++ b/package.json @@ -100,6 +100,7 @@ "@langchain/core": "^1.1.44", "@langchain/mistralai": "^1.0.8", "@langchain/openai": "^1.4.2", + "@mediapipe/selfie_segmentation": "^0.1.1675465747", "@radix-ui/react-accordion": "^1.2.12", "@radix-ui/react-dialog": "^1.1.15", "@radix-ui/react-dropdown-menu": "^2.1.16", diff --git a/public/mediapipe/selfie_segmentation/README.md b/public/mediapipe/selfie_segmentation/README.md new file mode 100644 index 000000000..81d6655d7 --- /dev/null +++ b/public/mediapipe/selfie_segmentation/README.md @@ -0,0 +1,48 @@ +# MediaPipe JavaScript Solutions + +MediaPipe offers out of the box solutions to use our ML technology with live and streaming media. + +Visit us as [mediapipe.dev]() + +See live demos of our JavaScript solutions at [code.mediapipe.dev/codepen]() + +For more information on each of the solutions and how to use them, visit https://google.github.io/mediapipe/getting_started/javascript. + + +--- + +## `selfie_segmentation_landscape.onnx` — derived, not vendored + +The `.onnx` beside the `.tflite` files is **generated from them**, by +[`scripts/convert-selfie-segmentation-to-onnx.py`](../../../scripts/convert-selfie-segmentation-to-onnx.py). +No weights were downloaded; it is a derived work of the MediaPipe model already vendored here +(Apache-2.0). + +It exists because the realtime path runs inference through ONNX Runtime rather than the +MediaPipe JS solution. Regenerate with: + +``` +pip install "numpy<2" "tensorflow==2.13.1" "tf2onnx==1.16.1" "onnx==1.16.2" "protobuf<4" +python scripts/convert-selfie-segmentation-to-onnx.py landscape +``` + +**The conversion is not mechanical.** `tf2onnx` exits 0 while leaving 12 operators that ONNX +Runtime cannot load — 11 `HardSwish` emitted into an opset-13 graph, and MediaPipe's custom +`TFL_Convolution2DTransposeBias`. The script repairs both; the reasoning is in its docstring. +If you regenerate, re-check the mask on a real frame rather than trusting the exit code. + +| | | +|---|---| +| input | `input_1` `[1, 144, 256, 3]` float32, **NHWC**, RGB scaled to 0..1 | +| output | `segment_back` `[1, 144, 256, 1]` float32, already sigmoid-activated | +| feeds | the compositor's `t3` mask slot (256x144 R8) | + +The graph is fully convolutional and resolution-agnostic, so the input dimensions can be +rewritten in place — but **both dimensions must be divisible by 16**, or the skip-connection +`Add`s fail on mismatched extents. Measured quality below 192x112 degrades visibly on a +full-screen camera, and at 64x48 the model stops producing a mask at all. + +> **Packaging:** this file currently sits under `public/`, which is bundled into `app.asar`. +> Anything that resolves a filesystem path for native code cannot read it from there — see +> `scripts/before-pack.cjs` and the compositor's asset handling. Whoever wires the loader +> should decide whether it moves to `extraResources` or is read through the renderer. diff --git a/public/mediapipe/selfie_segmentation/index.d.ts b/public/mediapipe/selfie_segmentation/index.d.ts new file mode 100644 index 000000000..3f3b87a87 --- /dev/null +++ b/public/mediapipe/selfie_segmentation/index.d.ts @@ -0,0 +1,111 @@ +/** + * @fileoverview Declarations for the face tracking API. + */ + +/** + * Version number of this package. + */ +export const VERSION: string; + +/** + * We support several ways to get image inputs. + */ +export type InputImage = HTMLVideoElement | HTMLImageElement | HTMLCanvasElement; + +/** + * Legal inputs. + */ +export interface InputMap { + image: InputImage; +} + +/** + * GpuBuffers should all be compatible with Canvas' `drawImage` + */ +type GpuBuffer = HTMLCanvasElement | HTMLImageElement | ImageBitmap; + +/** + * Possible results from SelfieSegmentation. + */ +export interface Results { + image: GpuBuffer; + segmentationMask: GpuBuffer; +} + +/** + * Configurable options for SelfieSegmentation. + */ +export interface Options { + selfieMode?: boolean; + modelSelection?: number; +} + +/** + * Listener for any results from SelfieSegmentation. + */ +export type ResultsListener = (results: Results) => Promise | void; + +/** + * Contains all of the setup options to drive the face solution. + */ +export interface SelfieSegmentationConfig { + locateFile?: (path: string, prefix?: string) => string; +} + +/** + * Declares the interface of SelfieSegmentation. + */ +declare interface SelfieSegmentationInterface { + close(): Promise; + onResults(listener: ResultsListener): void; + initialize(): Promise; + reset(): void; + send(inputs: InputMap): Promise; + setOptions(options: Options): void; +} + +/** + * Encapsulates the entire SelfieSegmentation solution. All that is needed from the + * developer is the source of the image data. The user will call `send` + * repeatedly and if a face is detected, then the user can receive callbacks + * with this metadata. + */ +export declare class SelfieSegmentation implements SelfieSegmentationInterface { + constructor(config?: SelfieSegmentationConfig); + + /** + * Shuts down the object. Call before creating a new instance. + */ + close(): Promise; + + /** + * Registers a single callback that will carry any results that occur + * after calling Send(). + */ + onResults(listener: ResultsListener): void; + + /** + * Initializes the solution. This includes loading ML models and mediapipe + * configurations, as well as setting up potential listeners for metadata. If + * `initialize` is not called manually, then it will be called the first time + * the developer calls `send`. + */ + initialize(): Promise; + + /** + * Tells the graph to restart before the next frame is sent. + */ + reset(): void; + + /** + * Processes a single frame of data, which depends on the options sent to the + * constructor. + */ + send(inputs: InputMap): Promise; + + /** + * Adjusts options in the solution. This may trigger a graph reload the next + * time the graph tries to run. + */ + setOptions(options: Options): void; +} diff --git a/public/mediapipe/selfie_segmentation/package.json b/public/mediapipe/selfie_segmentation/package.json new file mode 100644 index 000000000..f50683515 --- /dev/null +++ b/public/mediapipe/selfie_segmentation/package.json @@ -0,0 +1,29 @@ +{ + "name": "@mediapipe/selfie_segmentation", + "version": "0.1.1675465747", + "description": "Mediapipe Selfie Segmentation Solution", + "main": "selfie_segmentation.js", + "module": "selfie_segmentation.js", + "jsdelivr": "selfie_segmentation.js", + "unpkg": "selfie_segmentation.js", + "types": "index.d.ts", + "author": "mhays@google.com", + "license": "Apache-2.0", + "homepage": "https://google.github.io/mediapipe/solutions/selfie_segmentation", + "keywords": [ + "AR", + "ML", + "Augmented" + ], + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "dependencies": {}, + "browser": { + "node-fetch": false, + "util": false, + "crypto": false + }, + "sideEffects": [] +} diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation.binarypb b/public/mediapipe/selfie_segmentation/selfie_segmentation.binarypb new file mode 100644 index 000000000..b25528918 Binary files /dev/null and b/public/mediapipe/selfie_segmentation/selfie_segmentation.binarypb differ diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation.js b/public/mediapipe/selfie_segmentation/selfie_segmentation.js new file mode 100644 index 000000000..7599c4882 --- /dev/null +++ b/public/mediapipe/selfie_segmentation/selfie_segmentation.js @@ -0,0 +1,2803 @@ +(function () { + /* + + Copyright The Closure Library Authors. + SPDX-License-Identifier: Apache-2.0 +*/ + "use strict"; + var x; + function aa(a) { + var b = 0; + return function () { + return b < a.length ? { done: !1, value: a[b++] } : { done: !0 }; + }; + } + var ba = + "function" == typeof Object.defineProperties + ? Object.defineProperty + : function (a, b, c) { + if (a == Array.prototype || a == Object.prototype) return a; + a[b] = c.value; + return a; + }; + function ca(a) { + a = [ + "object" == typeof globalThis && globalThis, + a, + "object" == typeof window && window, + "object" == typeof self && self, + "object" == typeof global && global, + ]; + for (var b = 0; b < a.length; ++b) { + var c = a[b]; + if (c && c.Math == Math) return c; + } + throw Error("Cannot find global object"); + } + var y = ca(this); + function z(a, b) { + if (b) + a: { + var c = y; + a = a.split("."); + for (var d = 0; d < a.length - 1; d++) { + var e = a[d]; + if (!(e in c)) break a; + c = c[e]; + } + a = a[a.length - 1]; + d = c[a]; + b = b(d); + b != d && null != b && ba(c, a, { configurable: !0, writable: !0, value: b }); + } + } + z("Symbol", function (a) { + function b(g) { + if (this instanceof b) throw new TypeError("Symbol is not a constructor"); + return new c(d + (g || "") + "_" + e++, g); + } + function c(g, f) { + this.h = g; + ba(this, "description", { configurable: !0, writable: !0, value: f }); + } + if (a) return a; + c.prototype.toString = function () { + return this.h; + }; + var d = "jscomp_symbol_" + ((1e9 * Math.random()) >>> 0) + "_", + e = 0; + return b; + }); + z("Symbol.iterator", function (a) { + if (a) return a; + a = Symbol("Symbol.iterator"); + for ( + var b = + "Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array".split( + " ", + ), + c = 0; + c < b.length; + c++ + ) { + var d = y[b[c]]; + "function" === typeof d && + "function" != typeof d.prototype[a] && + ba(d.prototype, a, { + configurable: !0, + writable: !0, + value: function () { + return da(aa(this)); + }, + }); + } + return a; + }); + function da(a) { + a = { next: a }; + a[Symbol.iterator] = function () { + return this; + }; + return a; + } + function A(a) { + var b = "undefined" != typeof Symbol && Symbol.iterator && a[Symbol.iterator]; + return b ? b.call(a) : { next: aa(a) }; + } + function ea(a) { + if (!(a instanceof Array)) { + a = A(a); + for (var b, c = []; !(b = a.next()).done; ) c.push(b.value); + a = c; + } + return a; + } + var fa = + "function" == typeof Object.assign + ? Object.assign + : function (a, b) { + for (var c = 1; c < arguments.length; c++) { + var d = arguments[c]; + if (d) for (var e in d) Object.hasOwn(d, e) && (a[e] = d[e]); + } + return a; + }; + z("Object.assign", function (a) { + return a || fa; + }); + var ha = + "function" == typeof Object.create + ? Object.create + : function (a) { + function b() {} + b.prototype = a; + return new b(); + }, + ia; + if ("function" == typeof Object.setPrototypeOf) ia = Object.setPrototypeOf; + else { + var ja; + a: { + var ka = { a: !0 }, + la = {}; + try { + la.__proto__ = ka; + ja = la.a; + break a; + } catch (a) {} + ja = !1; + } + ia = ja + ? function (a, b) { + a.__proto__ = b; + if (a.__proto__ !== b) throw new TypeError(a + " is not extensible"); + return a; + } + : null; + } + var ma = ia; + function na(a, b) { + a.prototype = ha(b.prototype); + a.prototype.constructor = a; + if (ma) ma(a, b); + else + for (var c in b) + if ("prototype" != c) + if (Object.defineProperties) { + var d = Object.getOwnPropertyDescriptor(b, c); + d && Object.defineProperty(a, c, d); + } else a[c] = b[c]; + a.za = b.prototype; + } + function oa() { + this.m = !1; + this.j = null; + this.i = void 0; + this.h = 1; + this.v = this.s = 0; + this.l = null; + } + function pa(a) { + if (a.m) throw new TypeError("Generator is already running"); + a.m = !0; + } + oa.prototype.u = function (a) { + this.i = a; + }; + function qa(a, b) { + a.l = { ma: b, na: !0 }; + a.h = a.s || a.v; + } + oa.prototype.return = function (a) { + this.l = { return: a }; + this.h = this.v; + }; + function D(a, b, c) { + a.h = c; + return { value: b }; + } + function ra(a) { + this.h = new oa(); + this.i = a; + } + function sa(a, b) { + pa(a.h); + var c = a.h.j; + if (c) + return ta( + a, + "return" in c + ? c["return"] + : function (d) { + return { value: d, done: !0 }; + }, + b, + a.h.return, + ); + a.h.return(b); + return ua(a); + } + function ta(a, b, c, d) { + try { + var e = b.call(a.h.j, c); + if (!(e instanceof Object)) throw new TypeError("Iterator result " + e + " is not an object"); + if (!e.done) return (a.h.m = !1), e; + var g = e.value; + } catch (f) { + return (a.h.j = null), qa(a.h, f), ua(a); + } + a.h.j = null; + d.call(a.h, g); + return ua(a); + } + function ua(a) { + for (; a.h.h; ) + try { + var b = a.i(a.h); + if (b) return (a.h.m = !1), { value: b.value, done: !1 }; + } catch (c) { + (a.h.i = void 0), qa(a.h, c); + } + a.h.m = !1; + if (a.h.l) { + b = a.h.l; + a.h.l = null; + if (b.na) throw b.ma; + return { value: b.return, done: !0 }; + } + return { value: void 0, done: !0 }; + } + function va(a) { + this.next = function (b) { + pa(a.h); + a.h.j ? (b = ta(a, a.h.j.next, b, a.h.u)) : (a.h.u(b), (b = ua(a))); + return b; + }; + this.throw = function (b) { + pa(a.h); + a.h.j ? (b = ta(a, a.h.j["throw"], b, a.h.u)) : (qa(a.h, b), (b = ua(a))); + return b; + }; + this.return = function (b) { + return sa(a, b); + }; + this[Symbol.iterator] = function () { + return this; + }; + } + function wa(a) { + function b(d) { + return a.next(d); + } + function c(d) { + return a.throw(d); + } + return new Promise(function (d, e) { + function g(f) { + f.done ? d(f.value) : Promise.resolve(f.value).then(b, c).then(g, e); + } + g(a.next()); + }); + } + function E(a) { + return wa(new va(new ra(a))); + } + z("Promise", function (a) { + function b(f) { + this.i = 0; + this.j = void 0; + this.h = []; + this.u = !1; + var h = this.l(); + try { + f(h.resolve, h.reject); + } catch (k) { + h.reject(k); + } + } + function c() { + this.h = null; + } + function d(f) { + return f instanceof b + ? f + : new b(function (h) { + h(f); + }); + } + if (a) return a; + c.prototype.i = function (f) { + if (null == this.h) { + this.h = []; + var h = this; + this.j(function () { + h.m(); + }); + } + this.h.push(f); + }; + var e = y.setTimeout; + c.prototype.j = function (f) { + e(f, 0); + }; + c.prototype.m = function () { + for (; this.h && this.h.length; ) { + var f = this.h; + this.h = []; + for (var h = 0; h < f.length; ++h) { + var k = f[h]; + f[h] = null; + try { + k(); + } catch (l) { + this.l(l); + } + } + } + this.h = null; + }; + c.prototype.l = function (f) { + this.j(function () { + throw f; + }); + }; + b.prototype.l = function () { + function f(l) { + return function (m) { + k || ((k = !0), l.call(h, m)); + }; + } + var h = this, + k = !1; + return { resolve: f(this.I), reject: f(this.m) }; + }; + b.prototype.I = function (f) { + if (f === this) this.m(new TypeError("A Promise cannot resolve to itself")); + else if (f instanceof b) this.L(f); + else { + a: switch (typeof f) { + case "object": { + var h = null != f; + break a; + } + case "function": + h = !0; + break a; + default: + h = !1; + } + h ? this.F(f) : this.s(f); + } + }; + b.prototype.F = function (f) { + var h = void 0; + try { + h = f.then; + } catch (k) { + this.m(k); + return; + } + "function" == typeof h ? this.M(h, f) : this.s(f); + }; + b.prototype.m = function (f) { + this.v(2, f); + }; + b.prototype.s = function (f) { + this.v(1, f); + }; + b.prototype.v = function (f, h) { + if (0 != this.i) + throw Error( + "Cannot settle(" + f + ", " + h + "): Promise already settled in state" + this.i, + ); + this.i = f; + this.j = h; + 2 === this.i && this.K(); + this.H(); + }; + b.prototype.K = function () { + var f = this; + e(function () { + if (f.D()) { + var h = y.console; + "undefined" !== typeof h && h.error(f.j); + } + }, 1); + }; + b.prototype.D = function () { + if (this.u) return !1; + var f = y.CustomEvent, + h = y.Event, + k = y.dispatchEvent; + if ("undefined" === typeof k) return !0; + "function" === typeof f + ? (f = new f("unhandledrejection", { cancelable: !0 })) + : "function" === typeof h + ? (f = new h("unhandledrejection", { cancelable: !0 })) + : ((f = y.document.createEvent("CustomEvent")), + f.initCustomEvent("unhandledrejection", !1, !0, f)); + f.promise = this; + f.reason = this.j; + return k(f); + }; + b.prototype.H = function () { + if (null != this.h) { + for (var f = 0; f < this.h.length; ++f) g.i(this.h[f]); + this.h = null; + } + }; + var g = new c(); + b.prototype.L = function (f) { + var h = this.l(); + f.T(h.resolve, h.reject); + }; + b.prototype.M = function (f, h) { + var k = this.l(); + try { + f.call(h, k.resolve, k.reject); + } catch (l) { + k.reject(l); + } + }; + b.prototype.then = function (f, h) { + function k(p, n) { + return "function" == typeof p + ? function (q) { + try { + l(p(q)); + } catch (t) { + m(t); + } + } + : n; + } + var l, + m, + r = new b(function (p, n) { + l = p; + m = n; + }); + this.T(k(f, l), k(h, m)); + return r; + }; + b.prototype.catch = function (f) { + return this.then(void 0, f); + }; + b.prototype.T = function (f, h) { + function k() { + switch (l.i) { + case 1: + f(l.j); + break; + case 2: + h(l.j); + break; + default: + throw Error("Unexpected state: " + l.i); + } + } + var l = this; + null == this.h ? g.i(k) : this.h.push(k); + this.u = !0; + }; + b.resolve = d; + b.reject = function (f) { + return new b(function (h, k) { + k(f); + }); + }; + b.race = function (f) { + return new b(function (h, k) { + for (var l = A(f), m = l.next(); !m.done; m = l.next()) d(m.value).T(h, k); + }); + }; + b.all = function (f) { + var h = A(f), + k = h.next(); + return k.done + ? d([]) + : new b(function (l, m) { + function r(q) { + return function (t) { + p[q] = t; + n--; + 0 == n && l(p); + }; + } + var p = [], + n = 0; + do p.push(void 0), n++, d(k.value).T(r(p.length - 1), m), (k = h.next()); + while (!k.done); + }); + }; + return b; + }); + function xa(a, b) { + a instanceof String && (a += ""); + var c = 0, + d = !1, + e = { + next: function () { + if (!d && c < a.length) { + var g = c++; + return { value: b(g, a[g]), done: !1 }; + } + d = !0; + return { done: !0, value: void 0 }; + }, + }; + e[Symbol.iterator] = function () { + return e; + }; + return e; + } + z("Array.prototype.keys", function (a) { + return a + ? a + : function () { + return xa(this, function (b) { + return b; + }); + }; + }); + z("Array.prototype.fill", function (a) { + return a + ? a + : function (b, c, d) { + var e = this.length || 0; + 0 > c && (c = Math.max(0, e + c)); + if (null == d || d > e) d = e; + d = Number(d); + 0 > d && (d = Math.max(0, e + d)); + for (c = Number(c || 0); c < d; c++) this[c] = b; + return this; + }; + }); + function F(a) { + return a ? a : Array.prototype.fill; + } + z("Int8Array.prototype.fill", F); + z("Uint8Array.prototype.fill", F); + z("Uint8ClampedArray.prototype.fill", F); + z("Int16Array.prototype.fill", F); + z("Uint16Array.prototype.fill", F); + z("Int32Array.prototype.fill", F); + z("Uint32Array.prototype.fill", F); + z("Float32Array.prototype.fill", F); + z("Float64Array.prototype.fill", F); + z("Object.is", function (a) { + return a + ? a + : function (b, c) { + return b === c ? 0 !== b || 1 / b === 1 / c : b !== b && c !== c; + }; + }); + z("Array.prototype.includes", function (a) { + return a + ? a + : function (b, c) { + var d = this; + d instanceof String && (d = String(d)); + var e = d.length; + c = c || 0; + for (0 > c && (c = Math.max(c + e, 0)); c < e; c++) { + var g = d[c]; + if (g === b || Object.is(g, b)) return !0; + } + return !1; + }; + }); + z("String.prototype.includes", function (a) { + return a + ? a + : function (b, c) { + if (null == this) + throw new TypeError( + "The 'this' value for String.prototype.includes must not be null or undefined", + ); + if (b instanceof RegExp) + throw new TypeError( + "First argument to String.prototype.includes must not be a regular expression", + ); + return -1 !== this.indexOf(b, c || 0); + }; + }); + var ya = this || self; + function Aa(a, b) { + a = a.split("."); + var c = ya; + a[0] in c || "undefined" == typeof c.execScript || c.execScript("var " + a[0]); + for (var d; a.length && (d = a.shift()); ) + a.length || void 0 === b + ? c[d] && c[d] !== Object.prototype[d] + ? (c = c[d]) + : (c = c[d] = {}) + : (c[d] = b); + } + function Ba(a) { + var b; + a: { + if ((b = ya.navigator)) if ((b = b.userAgent)) break a; + b = ""; + } + return -1 != b.indexOf(a); + } + var Ca = Array.prototype.map + ? function (a, b) { + return Array.prototype.map.call(a, b, void 0); + } + : function (a, b) { + for ( + var c = a.length, d = Array(c), e = "string" === typeof a ? a.split("") : a, g = 0; + g < c; + g++ + ) + g in e && (d[g] = b.call(void 0, e[g], g, a)); + return d; + }; + var Da = {}, + Ea = null; + function Fa(a) { + var b = a.length, + c = (3 * b) / 4; + c % 3 + ? (c = Math.floor(c)) + : -1 != "=.".indexOf(a[b - 1]) && (c = -1 != "=.".indexOf(a[b - 2]) ? c - 2 : c - 1); + var d = new Uint8Array(c), + e = 0; + Ga(a, function (g) { + d[e++] = g; + }); + return e !== c ? d.subarray(0, e) : d; + } + function Ga(a, b) { + function c(k) { + for (; d < a.length; ) { + var l = a.charAt(d++), + m = Ea[l]; + if (null != m) return m; + if (!/^[\s\xa0]*$/.test(l)) throw Error("Unknown base64 encoding at char: " + l); + } + return k; + } + Ha(); + for (var d = 0; ; ) { + var e = c(-1), + g = c(0), + f = c(64), + h = c(64); + if (64 === h && -1 === e) break; + b((e << 2) | (g >> 4)); + 64 != f && (b(((g << 4) & 240) | (f >> 2)), 64 != h && b(((f << 6) & 192) | h)); + } + } + function Ha() { + if (!Ea) { + Ea = {}; + for ( + var a = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split(""), + b = ["+/=", "+/", "-_=", "-_.", "-_"], + c = 0; + 5 > c; + c++ + ) { + var d = a.concat(b[c].split("")); + Da[c] = d; + for (var e = 0; e < d.length; e++) { + var g = d[e]; + void 0 === Ea[g] && (Ea[g] = e); + } + } + } + } + var Ia = "undefined" !== typeof Uint8Array, + Ja = !(Ba("Trident") || Ba("MSIE")) && "function" === typeof ya.btoa; + function Ka(a) { + if (!Ja) { + var b; + void 0 === b && (b = 0); + Ha(); + b = Da[b]; + for ( + var c = Array(Math.floor(a.length / 3)), d = b[64] || "", e = 0, g = 0; + e < a.length - 2; + e += 3 + ) { + var f = a[e], + h = a[e + 1], + k = a[e + 2], + l = b[f >> 2]; + f = b[((f & 3) << 4) | (h >> 4)]; + h = b[((h & 15) << 2) | (k >> 6)]; + k = b[k & 63]; + c[g++] = l + f + h + k; + } + l = 0; + k = d; + switch (a.length - e) { + case 2: + (l = a[e + 1]), (k = b[(l & 15) << 2] || d); + case 1: + (a = a[e]), (c[g] = b[a >> 2] + b[((a & 3) << 4) | (l >> 4)] + k + d); + } + return c.join(""); + } + for (b = ""; 10240 < a.length; ) + (b += String.fromCharCode.apply(null, a.subarray(0, 10240))), (a = a.subarray(10240)); + b += String.fromCharCode.apply(null, a); + return btoa(b); + } + var La = RegExp("[-_.]", "g"); + function Ma(a) { + switch (a) { + case "-": + return "+"; + case "_": + return "/"; + case ".": + return "="; + default: + return ""; + } + } + function Na(a) { + if (!Ja) return Fa(a); + La.test(a) && (a = a.replace(La, Ma)); + a = atob(a); + for (var b = new Uint8Array(a.length), c = 0; c < a.length; c++) b[c] = a.charCodeAt(c); + return b; + } + var Oa; + function Pa() { + return Oa || (Oa = new Uint8Array(0)); + } + var Qa = {}; + var Ra = "function" === typeof Uint8Array.prototype.slice, + G = 0, + H = 0; + function Sa(a) { + var b = 0 > a; + a = Math.abs(a); + var c = a >>> 0; + a = Math.floor((a - c) / 4294967296); + b && ((c = A(Ta(c, a))), (b = c.next().value), (a = c.next().value), (c = b)); + G = c >>> 0; + H = a >>> 0; + } + var Ua = "function" === typeof BigInt; + function Ta(a, b) { + b = ~b; + a ? (a = ~a + 1) : (b += 1); + return [a, b]; + } + function Va(a, b) { + this.i = a >>> 0; + this.h = b >>> 0; + } + function Wa(a) { + if (!a) return Xa || (Xa = new Va(0, 0)); + if (!/^-?\d+$/.test(a)) return null; + if (16 > a.length) Sa(Number(a)); + else if (Ua) + (a = BigInt(a)), + (G = Number(a & BigInt(4294967295)) >>> 0), + (H = Number((a >> BigInt(32)) & BigInt(4294967295))); + else { + var b = +("-" === a[0]); + H = G = 0; + for (var c = a.length, d = b, e = ((c - b) % 6) + b; e <= c; d = e, e += 6) + (d = Number(a.slice(d, e))), + (H *= 1e6), + (G = 1e6 * G + d), + 4294967296 <= G && ((H += (G / 4294967296) | 0), (G %= 4294967296)); + b && ((b = A(Ta(G, H))), (a = b.next().value), (b = b.next().value), (G = a), (H = b)); + } + return new Va(G, H); + } + var Xa; + function Ya(a, b) { + return Error("Invalid wire type: " + a + " (at position " + b + ")"); + } + function Za() { + return Error("Failed to read varint, encoding is invalid."); + } + function $a(a, b) { + return Error("Tried to read past the end of the data " + b + " > " + a); + } + function K() { + throw Error("Invalid UTF8"); + } + function ab(a, b) { + b = String.fromCharCode.apply(null, b); + return null == a ? b : a + b; + } + var bb = void 0, + cb, + db = "undefined" !== typeof TextDecoder, + eb, + fb = "undefined" !== typeof TextEncoder; + var gb; + function hb(a) { + if (a !== Qa) throw Error("illegal external caller"); + } + function ib(a, b) { + hb(b); + this.V = a; + if (null != a && 0 === a.length) + throw Error("ByteString should be constructed with non-empty values"); + } + function jb() { + return gb || (gb = new ib(null, Qa)); + } + function kb(a) { + hb(Qa); + var b = a.V; + b = + null == b || (Ia && null != b && b instanceof Uint8Array) + ? b + : "string" === typeof b + ? Na(b) + : null; + return null == b ? b : (a.V = b); + } + function lb(a) { + if ("string" === typeof a) return { buffer: Na(a), C: !1 }; + if (Array.isArray(a)) return { buffer: new Uint8Array(a), C: !1 }; + if (a.constructor === Uint8Array) return { buffer: a, C: !1 }; + if (a.constructor === ArrayBuffer) return { buffer: new Uint8Array(a), C: !1 }; + if (a.constructor === ib) return { buffer: kb(a) || Pa(), C: !0 }; + if (a instanceof Uint8Array) + return { buffer: new Uint8Array(a.buffer, a.byteOffset, a.byteLength), C: !1 }; + throw Error( + "Type not convertible to a Uint8Array, expected a Uint8Array, an ArrayBuffer, a base64 encoded string, a ByteString or an Array of numbers", + ); + } + function mb(a, b) { + this.i = null; + this.m = !1; + this.h = this.j = this.l = 0; + nb(this, a, b); + } + function nb(a, b, c) { + c = void 0 === c ? {} : c; + a.S = void 0 === c.S ? !1 : c.S; + b && ((b = lb(b)), (a.i = b.buffer), (a.m = b.C), (a.l = 0), (a.j = a.i.length), (a.h = a.l)); + } + mb.prototype.reset = function () { + this.h = this.l; + }; + function L(a, b) { + a.h = b; + if (b > a.j) throw $a(a.j, b); + } + function ob(a) { + var b = a.i, + c = a.h, + d = b[c++], + e = d & 127; + if ( + d & 128 && + ((d = b[c++]), + (e |= (d & 127) << 7), + d & 128 && + ((d = b[c++]), + (e |= (d & 127) << 14), + d & 128 && + ((d = b[c++]), + (e |= (d & 127) << 21), + d & 128 && + ((d = b[c++]), + (e |= d << 28), + d & 128 && + b[c++] & 128 && + b[c++] & 128 && + b[c++] & 128 && + b[c++] & 128 && + b[c++] & 128)))) + ) + throw Za(); + L(a, c); + return e; + } + function pb(a, b) { + if (0 > b) throw Error("Tried to read a negative byte length: " + b); + var c = a.h, + d = c + b; + if (d > a.j) throw $a(b, a.j - c); + a.h = d; + return c; + } + var qb = []; + function rb() { + this.h = []; + } + rb.prototype.length = function () { + return this.h.length; + }; + rb.prototype.end = function () { + var a = this.h; + this.h = []; + return a; + }; + function sb(a, b, c) { + for (; 0 < c || 127 < b; ) + a.h.push((b & 127) | 128), (b = ((b >>> 7) | (c << 25)) >>> 0), (c >>>= 7); + a.h.push(b); + } + function M(a, b) { + for (; 127 < b; ) a.h.push((b & 127) | 128), (b >>>= 7); + a.h.push(b); + } + function tb(a, b) { + if (qb.length) { + var c = qb.pop(); + nb(c, a, b); + a = c; + } else a = new mb(a, b); + this.h = a; + this.j = this.h.h; + this.i = this.l = -1; + this.setOptions(b); + } + tb.prototype.setOptions = function (a) { + a = void 0 === a ? {} : a; + this.ca = void 0 === a.ca ? !1 : a.ca; + }; + tb.prototype.reset = function () { + this.h.reset(); + this.j = this.h.h; + this.i = this.l = -1; + }; + function ub(a) { + var b = a.h; + if (b.h == b.j) return !1; + a.j = a.h.h; + var c = ob(a.h) >>> 0; + b = c >>> 3; + c &= 7; + if (!(0 <= c && 5 >= c)) throw Ya(c, a.j); + if (1 > b) throw Error("Invalid field number: " + b + " (at position " + a.j + ")"); + a.l = b; + a.i = c; + return !0; + } + function vb(a) { + switch (a.i) { + case 0: + if (0 != a.i) vb(a); + else + a: { + a = a.h; + for (var b = a.h, c = b + 10, d = a.i; b < c; ) + if (0 === (d[b++] & 128)) { + L(a, b); + break a; + } + throw Za(); + } + break; + case 1: + a = a.h; + L(a, a.h + 8); + break; + case 2: + 2 != a.i ? vb(a) : ((b = ob(a.h) >>> 0), (a = a.h), L(a, a.h + b)); + break; + case 5: + a = a.h; + L(a, a.h + 4); + break; + case 3: + b = a.l; + do { + if (!ub(a)) throw Error("Unmatched start-group tag: stream EOF"); + if (4 == a.i) { + if (a.l != b) throw Error("Unmatched end-group tag"); + break; + } + vb(a); + } while (1); + break; + default: + throw Ya(a.i, a.j); + } + } + var wb = []; + function xb() { + this.j = []; + this.i = 0; + this.h = new rb(); + } + function N(a, b) { + 0 !== b.length && (a.j.push(b), (a.i += b.length)); + } + function yb(a, b) { + if ((b = b.R)) { + N(a, a.h.end()); + for (var c = 0; c < b.length; c++) N(a, kb(b[c]) || Pa()); + } + } + var O = "function" === typeof Symbol && "symbol" === typeof Symbol() ? Symbol() : void 0; + function P(a, b) { + if (O) return (a[O] |= b); + if (void 0 !== a.A) return (a.A |= b); + Object.defineProperties(a, { A: { value: b, configurable: !0, writable: !0, enumerable: !1 } }); + return b; + } + function zb(a, b) { + O ? a[O] && (a[O] &= ~b) : void 0 !== a.A && (a.A &= ~b); + } + function Q(a) { + var b; + O ? (b = a[O]) : (b = a.A); + return null == b ? 0 : b; + } + function R(a, b) { + O + ? (a[O] = b) + : void 0 !== a.A + ? (a.A = b) + : Object.defineProperties(a, { + A: { value: b, configurable: !0, writable: !0, enumerable: !1 }, + }); + } + function Ab(a) { + P(a, 1); + return a; + } + function Bb(a, b) { + R(b, (a | 0) & -51); + } + function Cb(a, b) { + R(b, (a | 18) & -41); + } + var Db = {}; + function Eb(a) { + return null !== a && "object" === typeof a && !Array.isArray(a) && a.constructor === Object; + } + var Fb, + Gb = []; + R(Gb, 23); + Fb = Object.freeze(Gb); + function Hb(a) { + if (Q(a.o) & 2) throw Error("Cannot mutate an immutable Message"); + } + function Ib(a) { + var b = a.length; + (b = b ? a[b - 1] : void 0) && Eb(b) ? (b.g = 1) : ((b = {}), a.push(((b.g = 1), b))); + } + function Jb(a) { + var b = a.i + a.G; + return a.B || (a.B = a.o[b] = {}); + } + function S(a, b) { + return -1 === b ? null : b >= a.i ? (a.B ? a.B[b] : void 0) : a.o[b + a.G]; + } + function U(a, b, c, d) { + Hb(a); + Kb(a, b, c, d); + } + function Kb(a, b, c, d) { + a.j && (a.j = void 0); + b >= a.i || d ? (Jb(a)[b] = c) : ((a.o[b + a.G] = c), (a = a.B) && b in a && delete a[b]); + } + function Lb(a, b, c, d) { + var e = S(a, b); + Array.isArray(e) || (e = Fb); + var g = Q(e); + g & 1 || Ab(e); + if (d) g & 2 || P(e, 2), c & 1 || Object.freeze(e); + else { + d = !(c & 2); + var f = g & 2; + c & 1 || !f + ? d && g & 16 && !f && zb(e, 16) + : ((e = Ab(Array.prototype.slice.call(e))), Kb(a, b, e)); + } + return e; + } + function Mb(a, b) { + var c = S(a, b); + var d = + null == c + ? c + : "number" === typeof c || "NaN" === c || "Infinity" === c || "-Infinity" === c + ? Number(c) + : void 0; + null != d && d !== c && Kb(a, b, d); + return d; + } + function Nb(a, b, c, d, e) { + a.h || (a.h = {}); + var g = a.h[c], + f = Lb(a, c, 3, e); + if (!g) { + var h = f; + g = []; + var k = !!(Q(a.o) & 16); + f = !!(Q(h) & 2); + var l = h; + !e && f && (h = Array.prototype.slice.call(h)); + for (var m = f, r = 0; r < h.length; r++) { + var p = h[r]; + var n = b, + q = !1; + q = void 0 === q ? !1 : q; + p = Array.isArray(p) ? new n(p) : q ? new n() : void 0; + if (void 0 !== p) { + n = p.o; + var t = (q = Q(n)); + f && (t |= 2); + k && (t |= 16); + t != q && R(n, t); + n = t; + m = m || !!(2 & n); + g.push(p); + } + } + a.h[c] = g; + k = Q(h); + b = k | 33; + b = m ? b & -9 : b | 8; + k != b && + ((m = h), Object.isFrozen(m) && (m = Array.prototype.slice.call(m)), R(m, b), (h = m)); + l !== h && Kb(a, c, h); + (e || (d && f)) && P(g, 2); + d && Object.freeze(g); + return g; + } + e || + ((e = Object.isFrozen(g)), + d && !e ? Object.freeze(g) : !d && e && ((g = Array.prototype.slice.call(g)), (a.h[c] = g))); + return g; + } + function Ob(a, b, c) { + var d = !!(Q(a.o) & 2); + b = Nb(a, b, c, d, d); + a = Lb(a, c, 3, d); + if (!(d || Q(a) & 8)) { + for (d = 0; d < b.length; d++) { + c = b[d]; + if (Q(c.o) & 2) { + var e = Pb(c, !1); + e.j = c; + } else e = c; + c !== e && ((b[d] = e), (a[d] = e.o)); + } + P(a, 8); + } + return b; + } + function V(a, b, c) { + if (null != c && "number" !== typeof c) + throw Error( + "Value of float/double field must be a number|null|undefined, found " + typeof c + ": " + c, + ); + U(a, b, c); + } + function Qb(a, b, c, d, e) { + Hb(a); + var g = Nb(a, c, b, !1, !1); + c = null != d ? d : new c(); + a = Lb(a, b, 2, !1); + void 0 != e ? (g.splice(e, 0, c), a.splice(e, 0, c.o)) : (g.push(c), a.push(c.o)); + c.C() && zb(a, 8); + return c; + } + function Rb(a, b) { + return null == a ? b : a; + } + function W(a, b, c) { + c = void 0 === c ? 0 : c; + return Rb(Mb(a, b), c); + } + var Sb; + function Tb(a) { + switch (typeof a) { + case "number": + return isFinite(a) ? a : String(a); + case "object": + if (a) + if (Array.isArray(a)) { + if (0 !== (Q(a) & 128)) return (a = Array.prototype.slice.call(a)), Ib(a), a; + } else { + if (Ia && null != a && a instanceof Uint8Array) return Ka(a); + if (a instanceof ib) { + var b = a.V; + return null == b ? "" : "string" === typeof b ? b : (a.V = Ka(b)); + } + } + } + return a; + } + function Ub(a, b, c, d) { + if (null != a) { + if (Array.isArray(a)) a = Vb(a, b, c, void 0 !== d); + else if (Eb(a)) { + var e = {}, + g; + for (g in a) e[g] = Ub(a[g], b, c, d); + a = e; + } else a = b(a, d); + return a; + } + } + function Vb(a, b, c, d) { + var e = Q(a); + d = d ? !!(e & 16) : void 0; + a = Array.prototype.slice.call(a); + for (var g = 0; g < a.length; g++) a[g] = Ub(a[g], b, c, d); + c(e, a); + return a; + } + function Wb(a) { + return a.ja === Db ? a.toJSON() : Tb(a); + } + function Xb(a, b) { + a & 128 && Ib(b); + } + function Yb(a, b, c) { + c = void 0 === c ? Cb : c; + if (null != a) { + if (Ia && a instanceof Uint8Array) return a.length ? new ib(new Uint8Array(a), Qa) : jb(); + if (Array.isArray(a)) { + var d = Q(a); + if (d & 2) return a; + if (b && !(d & 32) && (d & 16 || 0 === d)) return R(a, d | 2), a; + a = Vb(a, Yb, d & 4 ? Cb : c, !0); + b = Q(a); + b & 4 && b & 2 && Object.freeze(a); + return a; + } + return a.ja === Db ? Zb(a) : a; + } + } + function $b(a, b, c, d, e, g, f) { + if ((a = a.h && a.h[c])) { + d = Q(a); + d & 2 ? (d = a) : ((g = Ca(a, Zb)), Cb(d, g), Object.freeze(g), (d = g)); + Hb(b); + f = null == d ? Fb : Ab([]); + if (null != d) { + g = !!d.length; + for (a = 0; a < d.length; a++) { + var h = d[a]; + g = g && !(Q(h.o) & 2); + f[a] = h.o; + } + g = (g ? 8 : 0) | 1; + a = Q(f); + (a & g) !== g && (Object.isFrozen(f) && (f = Array.prototype.slice.call(f)), R(f, a | g)); + b.h || (b.h = {}); + b.h[c] = d; + } else b.h && (b.h[c] = void 0); + Kb(b, c, f, e); + } else U(b, c, Yb(d, g, f), e); + } + function Zb(a) { + if (Q(a.o) & 2) return a; + a = Pb(a, !0); + P(a.o, 2); + return a; + } + function Pb(a, b) { + var c = a.o, + d = []; + P(d, 16); + var e = a.constructor.h; + e && d.push(e); + e = a.B; + if (e) { + d.length = c.length; + d.fill(void 0, d.length, c.length); + var g = {}; + d[d.length - 1] = g; + } + 0 !== (Q(c) & 128) && Ib(d); + b = b || a.C() ? Cb : Bb; + g = a.constructor; + Sb = d; + d = new g(d); + Sb = void 0; + a.R && (d.R = a.R.slice()); + g = !!(Q(c) & 16); + for (var f = e ? c.length - 1 : c.length, h = 0; h < f; h++) $b(a, d, h - a.G, c[h], !1, g, b); + if (e) for (var k in e) $b(a, d, +k, e[k], !0, g, b); + return d; + } + function X(a, b, c) { + null == a && (a = Sb); + Sb = void 0; + var d = this.constructor.i || 0, + e = 0 < d, + g = this.constructor.h, + f = !1; + if (null == a) { + a = g ? [g] : []; + var h = 48; + var k = !0; + e && ((d = 0), (h |= 128)); + R(a, h); + } else { + if (!Array.isArray(a)) throw Error(); + if (g && g !== a[0]) throw Error(); + var l = (h = P(a, 0)); + if ((k = 0 !== (16 & l))) (f = 0 !== (32 & l)) || (l |= 32); + if (e) + if (128 & l) d = 0; + else { + if (0 < a.length) { + var m = a[a.length - 1]; + if (Eb(m) && "g" in m) { + d = 0; + l |= 128; + delete m.g; + var r = !0, + p; + for (p in m) { + r = !1; + break; + } + r && a.pop(); + } + } + } + else if (128 & l) throw Error(); + h !== l && R(a, l); + } + this.G = (g ? 0 : -1) - d; + this.h = void 0; + this.o = a; + a: { + g = this.o.length; + d = g - 1; + if (g && ((g = this.o[d]), Eb(g))) { + this.B = g; + this.i = d - this.G; + break a; + } + void 0 !== b && -1 < b + ? ((this.i = Math.max(b, d + 1 - this.G)), (this.B = void 0)) + : (this.i = Number.MAX_VALUE); + } + if (!e && this.B && "g" in this.B) + throw Error('Unexpected "g" flag in sparse object of message that is not a group type.'); + if (c) { + b = k && !f && !0; + e = this.i; + var n; + for (k = 0; k < c.length; k++) + (f = c[k]), + f < e + ? ((f += this.G), (d = a[f]) ? ac(d, b) : (a[f] = Fb)) + : (n || (n = Jb(this)), (d = n[f]) ? ac(d, b) : (n[f] = Fb)); + } + } + X.prototype.toJSON = function () { + return Vb(this.o, Wb, Xb); + }; + X.prototype.C = function () { + return !!(Q(this.o) & 2); + }; + function ac(a, b) { + if (Array.isArray(a)) { + var c = Q(a), + d = 1; + !b || c & 2 || (d |= 16); + (c & d) !== d && R(a, c | d); + } + } + X.prototype.ja = Db; + X.prototype.toString = function () { + return this.o.toString(); + }; + function bc(a, b, c) { + if (c) { + var d = {}, + e; + for (e in c) { + var g = c[e], + f = g.ra; + f || + ((d.J = g.xa || g.oa.W), + g.ia + ? ((d.aa = cc(g.ia)), + (f = (function (h) { + return function (k, l, m) { + return h.J(k, l, m, h.aa); + }; + })(d))) + : g.ka + ? ((d.Z = dc(g.da.P, g.ka)), + (f = (function (h) { + return function (k, l, m) { + return h.J(k, l, m, h.Z); + }; + })(d))) + : (f = d.J), + (g.ra = f)); + f(b, a, g.da); + d = { J: d.J, aa: d.aa, Z: d.Z }; + } + } + yb(b, a); + } + var ec = Symbol(); + function fc(a, b, c) { + return ( + a[ec] || + (a[ec] = function (d, e) { + return b(d, e, c); + }) + ); + } + function gc(a) { + var b = a[ec]; + if (!b) { + var c = hc(a); + b = function (d, e) { + return ic(d, e, c); + }; + a[ec] = b; + } + return b; + } + function jc(a) { + var b = a.ia; + if (b) return gc(b); + if ((b = a.wa)) return fc(a.da.P, b, a.ka); + } + function kc(a) { + var b = jc(a), + c = a.da, + d = a.oa.U; + return b + ? function (e, g) { + return d(e, g, c, b); + } + : function (e, g) { + return d(e, g, c); + }; + } + function lc(a, b) { + var c = a[b]; + "function" == typeof c && 0 === c.length && ((c = c()), (a[b] = c)); + return Array.isArray(c) && (mc in c || nc in c || (0 < c.length && "function" == typeof c[0])) + ? c + : void 0; + } + function oc(a, b, c, d, e, g) { + b.P = a[0]; + var f = 1; + if (a.length > f && "number" !== typeof a[f]) { + var h = a[f++]; + c(b, h); + } + for (; f < a.length; ) { + c = a[f++]; + for (var k = f + 1; k < a.length && "number" !== typeof a[k]; ) k++; + h = a[f++]; + k -= f; + switch (k) { + case 0: + d(b, c, h); + break; + case 1: + (k = lc(a, f)) ? (f++, e(b, c, h, k)) : d(b, c, h, a[f++]); + break; + case 2: + k = f++; + k = lc(a, k); + e(b, c, h, k, a[f++]); + break; + case 3: + g(b, c, h, a[f++], a[f++], a[f++]); + break; + case 4: + g(b, c, h, a[f++], a[f++], a[f++], a[f++]); + break; + default: + throw Error("unexpected number of binary field arguments: " + k); + } + } + return b; + } + var pc = Symbol(); + function cc(a) { + var b = a[pc]; + if (!b) { + var c = qc(a); + b = function (d, e) { + return rc(d, e, c); + }; + a[pc] = b; + } + return b; + } + function dc(a, b) { + var c = a[pc]; + c || + ((c = function (d, e) { + return bc(d, e, b); + }), + (a[pc] = c)); + return c; + } + var nc = Symbol(); + function sc(a, b) { + a.push(b); + } + function tc(a, b, c) { + a.push(b, c.W); + } + function uc(a, b, c, d) { + var e = cc(d), + g = qc(d).P, + f = c.W; + a.push(b, function (h, k, l) { + return f(h, k, l, g, e); + }); + } + function vc(a, b, c, d, e, g) { + var f = dc(d, g), + h = c.W; + a.push(b, function (k, l, m) { + return h(k, l, m, d, f); + }); + } + function qc(a) { + var b = a[nc]; + if (b) return b; + b = oc(a, (a[nc] = []), sc, tc, uc, vc); + mc in a && nc in a && (a.length = 0); + return b; + } + var mc = Symbol(); + function wc(a, b) { + a[0] = b; + } + function xc(a, b, c, d) { + var e = c.U; + a[b] = d + ? function (g, f, h) { + return e(g, f, h, d); + } + : e; + } + function yc(a, b, c, d, e) { + var g = c.U, + f = gc(d), + h = hc(d).P; + a[b] = function (k, l, m) { + return g(k, l, m, h, f, e); + }; + } + function zc(a, b, c, d, e, g, f) { + var h = c.U, + k = fc(d, e, g); + a[b] = function (l, m, r) { + return h(l, m, r, d, k, f); + }; + } + function hc(a) { + var b = a[mc]; + if (b) return b; + b = oc(a, (a[mc] = {}), wc, xc, yc, zc); + mc in a && nc in a && (a.length = 0); + return b; + } + function ic(a, b, c) { + for (; ub(b) && 4 != b.i; ) { + var d = b.l, + e = c[d]; + if (!e) { + var g = c[0]; + g && (g = g[d]) && (e = c[d] = kc(g)); + } + if (!e || !e(b, a, d)) { + e = b; + d = a; + g = e.j; + vb(e); + var f = e; + if (!f.ca) { + e = f.h.h - g; + f.h.h = g; + f = f.h; + if (0 == e) e = jb(); + else { + g = pb(f, e); + if (f.S && f.m) e = f.i.subarray(g, g + e); + else { + f = f.i; + var h = g; + e = g + e; + e = h === e ? Pa() : Ra ? f.slice(h, e) : new Uint8Array(f.subarray(h, e)); + } + e = 0 == e.length ? jb() : new ib(e, Qa); + } + (g = d.R) ? g.push(e) : (d.R = [e]); + } + } + } + return a; + } + function rc(a, b, c) { + for (var d = c.length, e = 1 == d % 2, g = e ? 1 : 0; g < d; g += 2) (0, c[g + 1])(b, a, c[g]); + bc(a, b, e ? c[0] : void 0); + } + function Ac(a, b) { + return { U: a, W: b }; + } + var Y = Ac( + function (a, b, c) { + if (5 !== a.i) return !1; + a = a.h; + var d = a.i, + e = a.h, + g = d[e]; + var f = d[e + 1]; + var h = d[e + 2]; + d = d[e + 3]; + L(a, a.h + 4); + f = ((g << 0) | (f << 8) | (h << 16) | (d << 24)) >>> 0; + a = 2 * (f >> 31) + 1; + g = (f >>> 23) & 255; + f &= 8388607; + U( + b, + c, + 255 == g + ? f + ? NaN + : Infinity * a + : 0 == g + ? a * Math.pow(2, -149) * f + : a * Math.pow(2, g - 150) * (f + Math.pow(2, 23)), + ); + return !0; + }, + function (a, b, c) { + b = Mb(b, c); + if (null != b) { + M(a.h, 8 * c + 5); + a = a.h; + var d = +b; + 0 === d + ? 0 < 1 / d + ? (G = H = 0) + : ((H = 0), (G = 2147483648)) + : isNaN(d) + ? ((H = 0), (G = 2147483647)) + : ((d = (c = 0 > d ? -2147483648 : 0) ? -d : d), + 3.4028234663852886e38 < d + ? ((H = 0), (G = (c | 2139095040) >>> 0)) + : 1.1754943508222875e-38 > d + ? ((d = Math.round(d / Math.pow(2, -149))), (H = 0), (G = (c | d) >>> 0)) + : ((b = Math.floor(Math.log(d) / Math.LN2)), + (d *= Math.pow(2, -b)), + (d = Math.round(8388608 * d)), + 16777216 <= d && ++b, + (H = 0), + (G = (c | ((b + 127) << 23) | (d & 8388607)) >>> 0))); + c = G; + a.h.push((c >>> 0) & 255); + a.h.push((c >>> 8) & 255); + a.h.push((c >>> 16) & 255); + a.h.push((c >>> 24) & 255); + } + }, + ), + Bc = Ac( + function (a, b, c) { + if (0 !== a.i) return !1; + var d = a.h, + e = 0, + g = (a = 0), + f = d.i, + h = d.h; + do { + var k = f[h++]; + e |= (k & 127) << g; + g += 7; + } while (32 > g && k & 128); + 32 < g && (a |= (k & 127) >> 4); + for (g = 3; 32 > g && k & 128; g += 7) (k = f[h++]), (a |= (k & 127) << g); + L(d, h); + if (128 > k) { + d = e >>> 0; + k = a >>> 0; + if ((a = k & 2147483648)) + (d = (~d + 1) >>> 0), (k = ~k >>> 0), 0 == d && (k = (k + 1) >>> 0); + d = 4294967296 * k + (d >>> 0); + } else throw Za(); + U(b, c, a ? -d : d); + return !0; + }, + function (a, b, c) { + b = S(b, c); + null != b && + ("string" === typeof b && Wa(b), + null != b && + (M(a.h, 8 * c), + "number" === typeof b + ? ((a = a.h), Sa(b), sb(a, G, H)) + : ((c = Wa(b)), sb(a.h, c.i, c.h)))); + }, + ), + Cc = Ac( + function (a, b, c) { + if (0 !== a.i) return !1; + U(b, c, ob(a.h)); + return !0; + }, + function (a, b, c) { + b = S(b, c); + if (null != b && null != b) + if ((M(a.h, 8 * c), (a = a.h), (c = b), 0 <= c)) M(a, c); + else { + for (b = 0; 9 > b; b++) a.h.push((c & 127) | 128), (c >>= 7); + a.h.push(1); + } + }, + ), + Dc = Ac( + function (a, b, c) { + if (2 !== a.i) return !1; + var d = ob(a.h) >>> 0; + a = a.h; + var e = pb(a, d); + a = a.i; + if (db) { + var g = a, + f; + (f = cb) || (f = cb = new TextDecoder("utf-8", { fatal: !0 })); + a = e + d; + g = 0 === e && a === g.length ? g : g.subarray(e, a); + try { + var h = f.decode(g); + } catch (r) { + if (void 0 === bb) { + try { + f.decode(new Uint8Array([128])); + } catch (p) {} + try { + f.decode(new Uint8Array([97])), (bb = !0); + } catch (p) { + bb = !1; + } + } + !bb && (cb = void 0); + throw r; + } + } else { + h = e; + d = h + d; + e = []; + for (var k = null, l, m; h < d; ) + (l = a[h++]), + 128 > l + ? e.push(l) + : 224 > l + ? h >= d + ? K() + : ((m = a[h++]), + 194 > l || 128 !== (m & 192) + ? (h--, K()) + : e.push(((l & 31) << 6) | (m & 63))) + : 240 > l + ? h >= d - 1 + ? K() + : ((m = a[h++]), + 128 !== (m & 192) || + (224 === l && 160 > m) || + (237 === l && 160 <= m) || + 128 !== ((g = a[h++]) & 192) + ? (h--, K()) + : e.push(((l & 15) << 12) | ((m & 63) << 6) | (g & 63))) + : 244 >= l + ? h >= d - 2 + ? K() + : ((m = a[h++]), + 128 !== (m & 192) || + 0 !== ((l << 28) + (m - 144)) >> 30 || + 128 !== ((g = a[h++]) & 192) || + 128 !== ((f = a[h++]) & 192) + ? (h--, K()) + : ((l = + ((l & 7) << 18) | ((m & 63) << 12) | ((g & 63) << 6) | (f & 63)), + (l -= 65536), + e.push(((l >> 10) & 1023) + 55296, (l & 1023) + 56320))) + : K(), + 8192 <= e.length && ((k = ab(k, e)), (e.length = 0)); + h = ab(k, e); + } + U(b, c, h); + return !0; + }, + function (a, b, c) { + b = S(b, c); + if (null != b) { + var d = !1; + d = void 0 === d ? !1 : d; + if (fb) { + if ( + d && + /(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])/.test(b) + ) + throw Error("Found an unpaired surrogate"); + b = (eb || (eb = new TextEncoder())).encode(b); + } else { + for (var e = 0, g = new Uint8Array(3 * b.length), f = 0; f < b.length; f++) { + var h = b.charCodeAt(f); + if (128 > h) g[e++] = h; + else { + if (2048 > h) g[e++] = (h >> 6) | 192; + else { + if (55296 <= h && 57343 >= h) { + if (56319 >= h && f < b.length) { + var k = b.charCodeAt(++f); + if (56320 <= k && 57343 >= k) { + h = 1024 * (h - 55296) + k - 56320 + 65536; + g[e++] = (h >> 18) | 240; + g[e++] = ((h >> 12) & 63) | 128; + g[e++] = ((h >> 6) & 63) | 128; + g[e++] = (h & 63) | 128; + continue; + } else f--; + } + if (d) throw Error("Found an unpaired surrogate"); + h = 65533; + } + g[e++] = (h >> 12) | 224; + g[e++] = ((h >> 6) & 63) | 128; + } + g[e++] = (h & 63) | 128; + } + } + b = e === g.length ? g : g.subarray(0, e); + } + M(a.h, 8 * c + 2); + M(a.h, b.length); + N(a, a.h.end()); + N(a, b); + } + }, + ), + Ec = Ac( + function (a, b, c, d, e) { + if (2 !== a.i) return !1; + b = Qb(b, c, d); + c = a.h.j; + d = ob(a.h) >>> 0; + var g = a.h.h + d, + f = g - c; + 0 >= f && ((a.h.j = g), e(b, a, void 0, void 0, void 0), (f = g - a.h.h)); + if (f) + throw Error( + "Message parsing ended unexpectedly. Expected to read " + + (d + + " bytes, instead read " + + (d - f) + + " bytes, either the data ended unexpectedly or the message misreported its own length"), + ); + a.h.h = g; + a.h.j = c; + return !0; + }, + function (a, b, c, d, e) { + b = Ob(b, d, c); + if (null != b) + for (d = 0; d < b.length; d++) { + var g = a; + M(g.h, 8 * c + 2); + var f = g.h.end(); + N(g, f); + f.push(g.i); + g = f; + e(b[d], a); + f = a; + var h = g.pop(); + for (h = f.i + f.h.length() - h; 127 < h; ) g.push((h & 127) | 128), (h >>>= 7), f.i++; + g.push(h); + f.i++; + } + }, + ); + function Fc(a) { + return function (b, c) { + a: { + if (wb.length) { + var d = wb.pop(); + d.setOptions(c); + nb(d.h, b, c); + b = d; + } else b = new tb(b, c); + try { + var e = hc(a); + var g = ic(new e.P(), b, e); + break a; + } finally { + (e = b.h), + (e.i = null), + (e.m = !1), + (e.l = 0), + (e.j = 0), + (e.h = 0), + (e.S = !1), + (b.l = -1), + (b.i = -1), + 100 > wb.length && wb.push(b); + } + g = void 0; + } + return g; + }; + } + function Gc(a) { + return function () { + var b = new xb(); + rc(this, b, qc(a)); + N(b, b.h.end()); + for (var c = new Uint8Array(b.i), d = b.j, e = d.length, g = 0, f = 0; f < e; f++) { + var h = d[f]; + c.set(h, g); + g += h.length; + } + b.j = [c]; + return c; + }; + } + function Z(a) { + X.call(this, a); + } + na(Z, X); + var Hc = [Z, 1, Cc, 2, Y, 3, Dc, 4, Dc]; + Z.prototype.l = Gc(Hc); + function Ic(a) { + X.call(this, a, -1, Jc); + } + na(Ic, X); + Ic.prototype.addClassification = function (a, b) { + Qb(this, 1, Z, a, b); + return this; + }; + var Jc = [1], + Kc = Fc([Ic, 1, Ec, Hc]); + function Lc(a) { + X.call(this, a); + } + na(Lc, X); + var Mc = [Lc, 1, Y, 2, Y, 3, Y, 4, Y, 5, Y]; + Lc.prototype.l = Gc(Mc); + function Nc(a) { + X.call(this, a, -1, Oc); + } + na(Nc, X); + var Oc = [1], + Pc = Fc([Nc, 1, Ec, Mc]); + function Qc(a) { + X.call(this, a); + } + na(Qc, X); + var Rc = [Qc, 1, Y, 2, Y, 3, Y, 4, Y, 5, Y, 6, Bc], + Sc = Fc(Rc); + Qc.prototype.l = Gc(Rc); + function Tc(a, b, c) { + c = a.createShader(0 === c ? a.VERTEX_SHADER : a.FRAGMENT_SHADER); + a.shaderSource(c, b); + a.compileShader(c); + if (!a.getShaderParameter(c, a.COMPILE_STATUS)) + throw Error("Could not compile WebGL shader.\n\n" + a.getShaderInfoLog(c)); + return c; + } + function Uc(a) { + return Ob(a, Z, 1).map(function (b) { + var c = S(b, 1); + return { + index: null == c ? 0 : c, + qa: W(b, 2), + label: null != S(b, 3) ? Rb(S(b, 3), "") : void 0, + displayName: null != S(b, 4) ? Rb(S(b, 4), "") : void 0, + }; + }); + } + function Vc(a) { + return { x: W(a, 1), y: W(a, 2), z: W(a, 3), visibility: null != Mb(a, 4) ? W(a, 4) : void 0 }; + } + function Wc(a, b) { + this.i = a; + this.h = b; + this.m = 0; + } + function Xc(a, b, c) { + Yc(a, b); + if ("function" === typeof a.h.canvas.transferToImageBitmap) + return Promise.resolve(a.h.canvas.transferToImageBitmap()); + if (c) return Promise.resolve(a.h.canvas); + if ("function" === typeof createImageBitmap) return createImageBitmap(a.h.canvas); + void 0 === a.j && (a.j = document.createElement("canvas")); + return new Promise(function (d) { + a.j.height = a.h.canvas.height; + a.j.width = a.h.canvas.width; + a.j.getContext("2d", {}).drawImage(a.h.canvas, 0, 0, a.h.canvas.width, a.h.canvas.height); + d(a.j); + }); + } + function Yc(a, b) { + var c = a.h; + if (void 0 === a.s) { + var d = Tc( + c, + "\n attribute vec2 aVertex;\n attribute vec2 aTex;\n varying vec2 vTex;\n void main(void) {\n gl_Position = vec4(aVertex, 0.0, 1.0);\n vTex = aTex;\n }", + 0, + ), + e = Tc( + c, + "\n precision mediump float;\n varying vec2 vTex;\n uniform sampler2D sampler0;\n void main(){\n gl_FragColor = texture2D(sampler0, vTex);\n }", + 1, + ), + g = c.createProgram(); + c.attachShader(g, d); + c.attachShader(g, e); + c.linkProgram(g); + if (!c.getProgramParameter(g, c.LINK_STATUS)) + throw Error("Could not compile WebGL program.\n\n" + c.getProgramInfoLog(g)); + d = a.s = g; + c.useProgram(d); + e = c.getUniformLocation(d, "sampler0"); + a.l = { O: c.getAttribLocation(d, "aVertex"), N: c.getAttribLocation(d, "aTex"), ya: e }; + a.v = c.createBuffer(); + c.bindBuffer(c.ARRAY_BUFFER, a.v); + c.enableVertexAttribArray(a.l.O); + c.vertexAttribPointer(a.l.O, 2, c.FLOAT, !1, 0, 0); + c.bufferData(c.ARRAY_BUFFER, new Float32Array([-1, -1, -1, 1, 1, 1, 1, -1]), c.STATIC_DRAW); + c.bindBuffer(c.ARRAY_BUFFER, null); + a.u = c.createBuffer(); + c.bindBuffer(c.ARRAY_BUFFER, a.u); + c.enableVertexAttribArray(a.l.N); + c.vertexAttribPointer(a.l.N, 2, c.FLOAT, !1, 0, 0); + c.bufferData(c.ARRAY_BUFFER, new Float32Array([0, 1, 0, 0, 1, 0, 1, 1]), c.STATIC_DRAW); + c.bindBuffer(c.ARRAY_BUFFER, null); + c.uniform1i(e, 0); + } + d = a.l; + c.useProgram(a.s); + c.canvas.width = b.width; + c.canvas.height = b.height; + c.viewport(0, 0, b.width, b.height); + c.activeTexture(c.TEXTURE0); + a.i.bindTexture2d(b.glName); + c.enableVertexAttribArray(d.O); + c.bindBuffer(c.ARRAY_BUFFER, a.v); + c.vertexAttribPointer(d.O, 2, c.FLOAT, !1, 0, 0); + c.enableVertexAttribArray(d.N); + c.bindBuffer(c.ARRAY_BUFFER, a.u); + c.vertexAttribPointer(d.N, 2, c.FLOAT, !1, 0, 0); + c.bindFramebuffer(c.DRAW_FRAMEBUFFER ? c.DRAW_FRAMEBUFFER : c.FRAMEBUFFER, null); + c.clearColor(0, 0, 0, 0); + c.clear(c.COLOR_BUFFER_BIT); + c.colorMask(!0, !0, !0, !0); + c.drawArrays(c.TRIANGLE_FAN, 0, 4); + c.disableVertexAttribArray(d.O); + c.disableVertexAttribArray(d.N); + c.bindBuffer(c.ARRAY_BUFFER, null); + a.i.bindTexture2d(0); + } + function Zc(a) { + this.h = a; + } + var $c = new Uint8Array([ + 0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 253, 15, 26, + 11, + ]); + function ad(a, b) { + return b + a; + } + function bd(a, b) { + window[a] = b; + } + function cd(a) { + var b = document.createElement("script"); + b.setAttribute("src", a); + b.setAttribute("crossorigin", "anonymous"); + return new Promise(function (c) { + b.addEventListener( + "load", + function () { + c(); + }, + !1, + ); + b.addEventListener( + "error", + function () { + c(); + }, + !1, + ); + document.body.appendChild(b); + }); + } + function dd() { + return E(function (a) { + switch (a.h) { + case 1: + return (a.s = 2), D(a, WebAssembly.instantiate($c), 4); + case 4: + a.h = 3; + a.s = 0; + break; + case 2: + return (a.s = 0), (a.l = null), a.return(!1); + case 3: + return a.return(!0); + } + }); + } + function ed(a) { + this.h = a; + this.listeners = {}; + this.l = {}; + this.L = {}; + this.s = {}; + this.v = {}; + this.M = this.u = this.ga = !0; + this.I = Promise.resolve(); + this.fa = ""; + this.D = {}; + this.locateFile = (a && a.locateFile) || ad; + if ("object" === typeof window) + var b = + window.location.pathname + .toString() + .substring(0, window.location.pathname.toString().lastIndexOf("/")) + "/"; + else if ("undefined" !== typeof location) + b = + location.pathname.toString().substring(0, location.pathname.toString().lastIndexOf("/")) + + "/"; + else throw Error("solutions can only be loaded on a web page or in a web worker"); + this.ha = b; + if (a.options) { + b = A(Object.keys(a.options)); + for (var c = b.next(); !c.done; c = b.next()) { + c = c.value; + var d = a.options[c].default; + void 0 !== d && (this.l[c] = "function" === typeof d ? d() : d); + } + } + } + x = ed.prototype; + x.close = function () { + this.j && this.j.delete(); + return Promise.resolve(); + }; + function fd(a) { + var b, c, d, e, g, f, h, k, l, m, r; + return E(function (p) { + switch (p.h) { + case 1: + if (!a.ga) return p.return(); + b = + void 0 === a.h.files + ? [] + : "function" === typeof a.h.files + ? a.h.files(a.l) + : a.h.files; + return D(p, dd(), 2); + case 2: + c = p.i; + if ("object" === typeof window) + return ( + bd("createMediapipeSolutionsWasm", { locateFile: a.locateFile }), + bd("createMediapipeSolutionsPackedAssets", { locateFile: a.locateFile }), + (f = b.filter(function (n) { + return void 0 !== n.data; + })), + (h = b.filter(function (n) { + return void 0 === n.data; + })), + (k = Promise.all( + f.map(function (n) { + var q = gd(a, n.url); + if (void 0 !== n.path) { + var t = n.path; + q = q.then(function (w) { + a.overrideFile(t, w); + return Promise.resolve(w); + }); + } + return q; + }), + )), + (l = Promise.all( + h.map(function (n) { + return void 0 === n.simd || (n.simd && c) || (!n.simd && !c) + ? cd(a.locateFile(n.url, a.ha)) + : Promise.resolve(); + }), + ).then(function () { + var n, q, t; + return E(function (w) { + if (1 == w.h) + return ( + (n = window.createMediapipeSolutionsWasm), + (q = window.createMediapipeSolutionsPackedAssets), + (t = a), + D(w, n(q), 2) + ); + t.i = w.i; + w.h = 0; + }); + })), + (m = (function () { + return E(function (n) { + a.h.graph && a.h.graph.url + ? (n = D(n, gd(a, a.h.graph.url), 0)) + : ((n.h = 0), (n = void 0)); + return n; + }); + })()), + D(p, Promise.all([l, k, m]), 7) + ); + if ("function" !== typeof importScripts) + throw Error("solutions can only be loaded on a web page or in a web worker"); + d = b + .filter(function (n) { + return void 0 === n.simd || (n.simd && c) || (!n.simd && !c); + }) + .map(function (n) { + return a.locateFile(n.url, a.ha); + }); + importScripts.apply(null, ea(d)); + e = a; + return D(p, createMediapipeSolutionsWasm(Module), 6); + case 6: + e.i = p.i; + a.m = new OffscreenCanvas(1, 1); + a.i.canvas = a.m; + g = a.i.GL.createContext(a.m, { + antialias: !1, + alpha: !1, + va: "undefined" !== typeof WebGL2RenderingContext ? 2 : 1, + }); + a.i.GL.makeContextCurrent(g); + p.h = 4; + break; + case 7: + a.m = document.createElement("canvas"); + r = a.m.getContext("webgl2", {}); + if (!r && ((r = a.m.getContext("webgl", {})), !r)) + return ( + alert("Failed to create WebGL canvas context when passing video frame."), p.return() + ); + a.K = r; + a.i.canvas = a.m; + a.i.createContext(a.m, !0, !0, {}); + case 4: + (a.j = new a.i.SolutionWasm()), (a.ga = !1), (p.h = 0); + } + }); + } + function hd(a) { + var b, c, d, e, g, f, h, k; + return E(function (l) { + if (1 == l.h) { + if (a.h.graph && a.h.graph.url && a.fa === a.h.graph.url) return l.return(); + a.u = !0; + if (!a.h.graph || !a.h.graph.url) { + l.h = 2; + return; + } + a.fa = a.h.graph.url; + return D(l, gd(a, a.h.graph.url), 3); + } + 2 != l.h && ((b = l.i), a.j.loadGraph(b)); + c = A(Object.keys(a.D)); + for (d = c.next(); !d.done; d = c.next()) (e = d.value), a.j.overrideFile(e, a.D[e]); + a.D = {}; + if (a.h.listeners) + for (g = A(a.h.listeners), f = g.next(); !f.done; f = g.next()) (h = f.value), id(a, h); + k = a.l; + a.l = {}; + a.setOptions(k); + l.h = 0; + }); + } + x.reset = function () { + var a = this; + return E(function (b) { + a.j && (a.j.reset(), (a.s = {}), (a.v = {})); + b.h = 0; + }); + }; + x.setOptions = function (a, b) { + var c = this; + if ((b = b || this.h.options)) { + for ( + var d = [], e = [], g = {}, f = A(Object.keys(a)), h = f.next(); + !h.done; + g = { X: g.X, Y: g.Y }, h = f.next() + ) + if (((h = h.value), !(h in this.l && this.l[h] === a[h]))) { + this.l[h] = a[h]; + var k = b[h]; + void 0 !== k && + (k.onChange && + ((g.X = k.onChange), + (g.Y = a[h]), + d.push( + (function (l) { + return function () { + var m; + return E(function (r) { + if (1 == r.h) return D(r, l.X(l.Y), 2); + m = r.i; + !0 === m && (c.u = !0); + r.h = 0; + }); + }; + })(g), + )), + k.graphOptionXref && + ((h = Object.assign( + {}, + { calculatorName: "", calculatorIndex: 0 }, + k.graphOptionXref, + { + valueNumber: 1 === k.type ? a[h] : 0, + valueBoolean: 0 === k.type ? a[h] : !1, + valueString: 2 === k.type ? a[h] : "", + }, + )), + e.push(h))); + } + if (0 !== d.length || 0 !== e.length) + (this.u = !0), + (this.H = (void 0 === this.H ? [] : this.H).concat(e)), + (this.F = (void 0 === this.F ? [] : this.F).concat(d)); + } + }; + function jd(a) { + var b, c, d, e, g, f, h; + return E(function (k) { + switch (k.h) { + case 1: + if (!a.u) return k.return(); + if (!a.F) { + k.h = 2; + break; + } + b = A(a.F); + c = b.next(); + case 3: + if (c.done) { + k.h = 5; + break; + } + d = c.value; + return D(k, d(), 4); + case 4: + c = b.next(); + k.h = 3; + break; + case 5: + a.F = void 0; + case 2: + if (a.H) { + e = new a.i.GraphOptionChangeRequestList(); + g = A(a.H); + for (f = g.next(); !f.done; f = g.next()) (h = f.value), e.push_back(h); + a.j.changeOptions(e); + e.delete(); + a.H = void 0; + } + a.u = !1; + k.h = 0; + } + }); + } + x.initialize = function () { + var a = this; + return E(function (b) { + return 1 == b.h ? D(b, fd(a), 2) : 3 != b.h ? D(b, hd(a), 3) : D(b, jd(a), 0); + }); + }; + function gd(a, b) { + var c, d; + return E(function (e) { + if (b in a.L) return e.return(a.L[b]); + c = a.locateFile(b, ""); + d = fetch(c).then(function (g) { + return g.arrayBuffer(); + }); + a.L[b] = d; + return e.return(d); + }); + } + x.overrideFile = function (a, b) { + this.j ? this.j.overrideFile(a, b) : (this.D[a] = b); + }; + x.clearOverriddenFiles = function () { + this.D = {}; + this.j && this.j.clearOverriddenFiles(); + }; + x.send = function (a, b) { + var c = this, + d, + e, + g, + f, + h, + k, + l, + m, + r; + return E(function (p) { + switch (p.h) { + case 1: + if (!c.h.inputs) return p.return(); + d = 1e3 * (void 0 === b || null === b ? performance.now() : b); + return D(p, c.I, 2); + case 2: + return D(p, c.initialize(), 3); + case 3: + e = new c.i.PacketDataList(); + g = A(Object.keys(a)); + for (f = g.next(); !f.done; f = g.next()) + if (((h = f.value), (k = c.h.inputs[h]))) { + a: { + var n = a[h]; + switch (k.type) { + case "video": { + var q = c.s[k.stream]; + q || ((q = new Wc(c.i, c.K)), (c.s[k.stream] = q)); + 0 === q.m && (q.m = q.i.createTexture()); + if ("undefined" !== typeof HTMLVideoElement && n instanceof HTMLVideoElement) { + var t = n.videoWidth; + var w = n.videoHeight; + } else + "undefined" !== typeof HTMLImageElement && n instanceof HTMLImageElement + ? ((t = n.naturalWidth), (w = n.naturalHeight)) + : ((t = n.width), (w = n.height)); + w = { glName: q.m, width: t, height: w }; + t = q.h; + t.canvas.width = w.width; + t.canvas.height = w.height; + t.activeTexture(t.TEXTURE0); + q.i.bindTexture2d(q.m); + t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, t.RGBA, t.UNSIGNED_BYTE, n); + q.i.bindTexture2d(0); + q = w; + break a; + } + case "detections": + q = c.s[k.stream]; + q || ((q = new Zc(c.i)), (c.s[k.stream] = q)); + q.data || (q.data = new q.h.DetectionListData()); + q.data.reset(n.length); + for (w = 0; w < n.length; ++w) { + t = n[w]; + var v = q.data, + B = v.setBoundingBox, + J = w; + var I = t.la; + var u = new Qc(); + V(u, 1, I.sa); + V(u, 2, I.ta); + V(u, 3, I.height); + V(u, 4, I.width); + V(u, 5, I.rotation); + U(u, 6, I.pa); + I = u.l(); + B.call(v, J, I); + if (t.ea) + for (v = 0; v < t.ea.length; ++v) { + u = t.ea[v]; + B = q.data; + J = B.addNormalizedLandmark; + I = w; + u = Object.assign({}, u, { visibility: u.visibility ? u.visibility : 0 }); + var C = new Lc(); + V(C, 1, u.x); + V(C, 2, u.y); + V(C, 3, u.z); + u.visibility && V(C, 4, u.visibility); + u = C.l(); + J.call(B, I, u); + } + if (t.ba) + for (v = 0; v < t.ba.length; ++v) + (B = q.data), + (J = B.addClassification), + (I = w), + (u = t.ba[v]), + (C = new Z()), + V(C, 2, u.qa), + u.index && U(C, 1, u.index), + u.label && U(C, 3, u.label), + u.displayName && U(C, 4, u.displayName), + (u = C.l()), + J.call(B, I, u); + } + q = q.data; + break a; + default: + q = {}; + } + } + l = q; + m = k.stream; + switch (k.type) { + case "video": + e.pushTexture2d(Object.assign({}, l, { stream: m, timestamp: d })); + break; + case "detections": + r = l; + r.stream = m; + r.timestamp = d; + e.pushDetectionList(r); + break; + default: + throw Error("Unknown input config type: '" + k.type + "'"); + } + } + c.j.send(e); + return D(p, c.I, 4); + case 4: + e.delete(), (p.h = 0); + } + }); + }; + function kd(a, b, c) { + var d, e, g, f, h, k, l, m, r, p, n, q, t, w; + return E(function (v) { + switch (v.h) { + case 1: + if (!c) return v.return(b); + d = {}; + e = 0; + g = A(Object.keys(c)); + for (f = g.next(); !f.done; f = g.next()) + (h = f.value), + (k = c[h]), + "string" !== typeof k && "texture" === k.type && void 0 !== b[k.stream] && ++e; + 1 < e && (a.M = !1); + l = A(Object.keys(c)); + f = l.next(); + case 2: + if (f.done) { + v.h = 4; + break; + } + m = f.value; + r = c[m]; + if ("string" === typeof r) return (t = d), (w = m), D(v, ld(a, m, b[r]), 14); + p = b[r.stream]; + if ("detection_list" === r.type) { + if (p) { + var B = p.getRectList(); + for ( + var J = p.getLandmarksList(), I = p.getClassificationsList(), u = [], C = 0; + C < B.size(); + ++C + ) { + var T = Sc(B.get(C)), + od = W(T, 1), + pd = W(T, 2), + qd = W(T, 3), + rd = W(T, 4), + sd = W(T, 5, 0), + za = void 0; + za = void 0 === za ? 0 : za; + T = { + la: { sa: od, ta: pd, height: qd, width: rd, rotation: sd, pa: Rb(S(T, 6), za) }, + ea: Ob(Pc(J.get(C)), Lc, 1).map(Vc), + ba: Uc(Kc(I.get(C))), + }; + u.push(T); + } + B = u; + } else B = []; + d[m] = B; + v.h = 7; + break; + } + if ("proto_list" === r.type) { + if (p) { + B = Array(p.size()); + for (J = 0; J < p.size(); J++) B[J] = p.get(J); + p.delete(); + } else B = []; + d[m] = B; + v.h = 7; + break; + } + if (void 0 === p) { + v.h = 3; + break; + } + if ("float_list" === r.type) { + d[m] = p; + v.h = 7; + break; + } + if ("proto" === r.type) { + d[m] = p; + v.h = 7; + break; + } + if ("texture" !== r.type) throw Error("Unknown output config type: '" + r.type + "'"); + n = a.v[m]; + n || ((n = new Wc(a.i, a.K)), (a.v[m] = n)); + return D(v, Xc(n, p, a.M), 13); + case 13: + (q = v.i), (d[m] = q); + case 7: + r.transform && d[m] && (d[m] = r.transform(d[m])); + v.h = 3; + break; + case 14: + t[w] = v.i; + case 3: + f = l.next(); + v.h = 2; + break; + case 4: + return v.return(d); + } + }); + } + function ld(a, b, c) { + var d; + return E(function (e) { + return "number" === typeof c || c instanceof Uint8Array || c instanceof a.i.Uint8BlobList + ? e.return(c) + : c instanceof a.i.Texture2dDataOut + ? ((d = a.v[b]), d || ((d = new Wc(a.i, a.K)), (a.v[b] = d)), e.return(Xc(d, c, a.M))) + : e.return(void 0); + }); + } + function id(a, b) { + for ( + var c = b.name || "$", + d = [].concat(ea(b.wants)), + e = new a.i.StringList(), + g = A(b.wants), + f = g.next(); + !f.done; + f = g.next() + ) + e.push_back(f.value); + g = a.i.PacketListener.implement({ + onResults: function (h) { + for (var k = {}, l = 0; l < b.wants.length; ++l) k[d[l]] = h.get(l); + var m = a.listeners[c]; + m && + (a.I = kd(a, k, b.outs).then(function (r) { + r = m(r); + for (var p = 0; p < b.wants.length; ++p) { + var n = k[d[p]]; + "object" === typeof n && n.hasOwnProperty && Object.hasOwn(n, "delete") && n.delete(); + } + r && (a.I = r); + })); + }, + }); + a.j.attachMultiListener(e, g); + e.delete(); + } + x.onResults = function (a, b) { + this.listeners[b || "$"] = a; + }; + Aa("Solution", ed); + Aa("OptionType", { BOOL: 0, NUMBER: 1, ua: 2, 0: "BOOL", 1: "NUMBER", 2: "STRING" }); + function md(a) { + void 0 === a && (a = 0); + switch (a) { + case 1: + return "selfie_segmentation_landscape.tflite"; + default: + return "selfie_segmentation.tflite"; + } + } + function nd(a) { + var b = this; + a = a || {}; + this.h = new ed({ + locateFile: a.locateFile, + files: function (c) { + return [ + { simd: !0, url: "selfie_segmentation_solution_simd_wasm_bin.js" }, + { simd: !1, url: "selfie_segmentation_solution_wasm_bin.js" }, + { data: !0, url: md(c.modelSelection) }, + ]; + }, + graph: { url: "selfie_segmentation.binarypb" }, + listeners: [ + { + wants: ["segmentation_mask", "image_transformed"], + outs: { + image: { type: "texture", stream: "image_transformed" }, + segmentationMask: { type: "texture", stream: "segmentation_mask" }, + }, + }, + ], + inputs: { image: { type: "video", stream: "input_frames_gpu" } }, + options: { + useCpuInference: { + type: 0, + graphOptionXref: { + calculatorType: "InferenceCalculator", + fieldName: "use_cpu_inference", + }, + default: + "object" !== typeof window || void 0 === window.navigator + ? !1 + : "iPad Simulator;iPhone Simulator;iPod Simulator;iPad;iPhone;iPod" + .split(";") + .includes(navigator.platform) || + (navigator.userAgent.includes("Mac") && "ontouchend" in document), + }, + selfieMode: { + type: 0, + graphOptionXref: { + calculatorType: "GlScalerCalculator", + calculatorIndex: 1, + fieldName: "flip_horizontal", + }, + }, + modelSelection: { + type: 1, + graphOptionXref: { + calculatorType: "ConstantSidePacketCalculator", + calculatorName: "ConstantSidePacketCalculatorModelSelection", + fieldName: "int_value", + }, + onChange: function (c) { + var d, e, g; + return E(function (f) { + if (1 == f.h) + return ( + (d = md(c)), + (e = "third_party/mediapipe/modules/selfie_segmentation/" + d), + D(f, gd(b.h, d), 2) + ); + g = f.i; + b.h.overrideFile(e, g); + return f.return(!0); + }); + }, + }, + }, + }); + } + x = nd.prototype; + x.close = function () { + this.h.close(); + return Promise.resolve(); + }; + x.onResults = function (a) { + this.h.onResults(a); + }; + x.initialize = function () { + var a = this; + return E(function (b) { + return D(b, a.h.initialize(), 0); + }); + }; + x.reset = function () { + this.h.reset(); + }; + x.send = function (a) { + var b = this; + return E(function (c) { + return D(c, b.h.send(a), 0); + }); + }; + x.setOptions = function (a) { + this.h.setOptions(a); + }; + Aa("SelfieSegmentation", nd); + Aa("VERSION", "0.1.1675465747"); +}).call(this); diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation.tflite b/public/mediapipe/selfie_segmentation/selfie_segmentation.tflite new file mode 100644 index 000000000..374c0720d Binary files /dev/null and b/public/mediapipe/selfie_segmentation/selfie_segmentation.tflite differ diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.onnx b/public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.onnx new file mode 100644 index 000000000..1fdedb18c Binary files /dev/null and b/public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.onnx differ diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.tflite b/public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.tflite new file mode 100644 index 000000000..4ea3f8a10 Binary files /dev/null and b/public/mediapipe/selfie_segmentation/selfie_segmentation_landscape.tflite differ diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_simd_wasm_bin.data b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_simd_wasm_bin.data new file mode 100644 index 000000000..e69de29bb diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_simd_wasm_bin.js b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_simd_wasm_bin.js new file mode 100644 index 000000000..919700dbe --- /dev/null +++ b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_simd_wasm_bin.js @@ -0,0 +1,11354 @@ +var createMediapipeSolutionsWasm = (() => { + var _scriptDir = + typeof document !== "undefined" && document.currentScript + ? document.currentScript.src + : undefined; + if (typeof __filename !== "undefined") _scriptDir = _scriptDir || __filename; + return function (createMediapipeSolutionsWasm) { + createMediapipeSolutionsWasm = createMediapipeSolutionsWasm || {}; + + var Module = + typeof createMediapipeSolutionsWasm != "undefined" ? createMediapipeSolutionsWasm : {}; + var readyPromiseResolve, readyPromiseReject; + Module["ready"] = new Promise(function (resolve, reject) { + readyPromiseResolve = resolve; + readyPromiseReject = reject; + }); + [ + "_main", + "_fflush", + "___getTypeName", + "__embind_initialize_bindings", + "onRuntimeInitialized", + ].forEach((prop) => { + if (!Object.getOwnPropertyDescriptor(Module["ready"], prop)) { + Object.defineProperty(Module["ready"], prop, { + get: () => + abort( + "You are getting " + + prop + + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js", + ), + set: () => + abort( + "You are setting " + + prop + + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js", + ), + }); + } + }); + var moduleOverrides = Object.assign({}, Module); + var arguments_ = []; + var thisProgram = "./this.program"; + var quit_ = (status, toThrow) => { + throw toThrow; + }; + var ENVIRONMENT_IS_WEB = typeof window == "object"; + var ENVIRONMENT_IS_WORKER = typeof importScripts == "function"; + var ENVIRONMENT_IS_NODE = + typeof process == "object" && + typeof process.versions == "object" && + typeof process.versions.node == "string"; + var ENVIRONMENT_IS_SHELL = + !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + if (Module["ENVIRONMENT"]) { + throw new Error( + "Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)", + ); + } + var scriptDirectory = ""; + function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; + } + var read_, readAsync, readBinary, setWindowTitle; + function logExceptionOnExit(e) { + if (e instanceof ExitStatus) return; + let toLog = e; + if (e && typeof e == "object" && e.stack) { + toLog = [e, e.stack]; + } + err("exiting due to exception: " + toLog); + } + if (ENVIRONMENT_IS_NODE) { + if (typeof process == "undefined" || !process.release || process.release.name !== "node") + throw new Error( + "not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)", + ); + var fs = require("fs"); + var nodePath = require("path"); + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = nodePath.dirname(scriptDirectory) + "/"; + } else { + scriptDirectory = __dirname + "/"; + } + read_ = (filename, binary) => { + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + return fs.readFileSync(filename, binary ? undefined : "utf8"); + }; + readBinary = (filename) => { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + readAsync = (filename, onload, onerror) => { + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + fs.readFile(filename, function (err, data) { + if (err) onerror(err); + else onload(data.buffer); + }); + }; + if (process["argv"].length > 1) { + thisProgram = process["argv"][1].replace(/\\/g, "/"); + } + arguments_ = process["argv"].slice(2); + process["on"]("uncaughtException", function (ex) { + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + process["on"]("unhandledRejection", function (reason) { + throw reason; + }); + quit_ = (status, toThrow) => { + if (keepRuntimeAlive()) { + process["exitCode"] = status; + throw toThrow; + } + logExceptionOnExit(toThrow); + process["exit"](status); + }; + Module["inspect"] = function () { + return "[Emscripten Module object]"; + }; + } else if (ENVIRONMENT_IS_SHELL) { + if ( + (typeof process == "object" && typeof require === "function") || + typeof window == "object" || + typeof importScripts == "function" + ) + throw new Error( + "not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)", + ); + if (typeof read != "undefined") { + read_ = function shell_read(f) { + return read(f); + }; + } + readBinary = function readBinary(f) { + let data; + if (typeof readbuffer == "function") { + return new Uint8Array(readbuffer(f)); + } + data = read(f, "binary"); + assert(typeof data == "object"); + return data; + }; + readAsync = function readAsync(f, onload, onerror) { + setTimeout(() => onload(readBinary(f)), 0); + }; + if (typeof scriptArgs != "undefined") { + arguments_ = scriptArgs; + } else if (typeof arguments != "undefined") { + arguments_ = arguments; + } + if (typeof quit == "function") { + quit_ = (status, toThrow) => { + logExceptionOnExit(toThrow); + quit(status); + }; + } + if (typeof print != "undefined") { + if (typeof console == "undefined") console = {}; + console.log = print; + console.warn = console.error = typeof printErr != "undefined" ? printErr : print; + } + } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = self.location.href; + } else if (typeof document != "undefined" && document.currentScript) { + scriptDirectory = document.currentScript.src; + } + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + if (scriptDirectory.indexOf("blob:") !== 0) { + scriptDirectory = scriptDirectory.substr( + 0, + scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1, + ); + } else { + scriptDirectory = ""; + } + if (!(typeof window == "object" || typeof importScripts == "function")) + throw new Error( + "not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)", + ); + { + read_ = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.send(null); + return xhr.responseText; + }; + if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + } + setWindowTitle = (title) => (document.title = title); + } else { + throw new Error("environment detection error"); + } + var out = Module["print"] || console.log.bind(console); + var err = Module["printErr"] || console.warn.bind(console); + Object.assign(Module, moduleOverrides); + moduleOverrides = null; + checkIncomingModuleAPI(); + if (Module["arguments"]) arguments_ = Module["arguments"]; + legacyModuleProp("arguments", "arguments_"); + if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; + legacyModuleProp("thisProgram", "thisProgram"); + if (Module["quit"]) quit_ = Module["quit"]; + legacyModuleProp("quit", "quit_"); + assert( + typeof Module["memoryInitializerPrefixURL"] == "undefined", + "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead", + ); + assert( + typeof Module["pthreadMainPrefixURL"] == "undefined", + "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead", + ); + assert( + typeof Module["cdInitializerPrefixURL"] == "undefined", + "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead", + ); + assert( + typeof Module["filePackagePrefixURL"] == "undefined", + "Module.filePackagePrefixURL option was removed, use Module.locateFile instead", + ); + assert( + typeof Module["read"] == "undefined", + "Module.read option was removed (modify read_ in JS)", + ); + assert( + typeof Module["readAsync"] == "undefined", + "Module.readAsync option was removed (modify readAsync in JS)", + ); + assert( + typeof Module["readBinary"] == "undefined", + "Module.readBinary option was removed (modify readBinary in JS)", + ); + assert( + typeof Module["setWindowTitle"] == "undefined", + "Module.setWindowTitle option was removed (modify setWindowTitle in JS)", + ); + assert( + typeof Module["TOTAL_MEMORY"] == "undefined", + "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY", + ); + legacyModuleProp("read", "read_"); + legacyModuleProp("readAsync", "readAsync"); + legacyModuleProp("readBinary", "readBinary"); + legacyModuleProp("setWindowTitle", "setWindowTitle"); + assert( + !ENVIRONMENT_IS_SHELL, + "shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable.", + ); + var POINTER_SIZE = 4; + function legacyModuleProp(prop, newName) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get: function () { + abort( + "Module." + + prop + + " has been replaced with plain " + + newName + + " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)", + ); + }, + }); + } + } + function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort( + "`Module." + + prop + + "` was supplied but `" + + prop + + "` not included in INCOMING_MODULE_JS_API", + ); + } + } + function isExportedByForceFilesystem(name) { + return ( + name === "FS_createPath" || + name === "FS_createDataFile" || + name === "FS_createPreloadedFile" || + name === "FS_unlink" || + name === "addRunDependency" || + name === "FS_createLazyFile" || + name === "FS_createDevice" || + name === "removeRunDependency" + ); + } + function missingLibrarySymbol(sym) { + if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) { + Object.defineProperty(globalThis, sym, { + configurable: true, + get: function () { + var msg = + "`" + + sym + + "` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line"; + var librarySymbol = sym; + if (!librarySymbol.startsWith("_")) { + librarySymbol = "$" + sym; + } + msg += " (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE=" + librarySymbol + ")"; + if (isExportedByForceFilesystem(sym)) { + msg += + ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"; + } + warnOnce(msg); + return undefined; + }, + }); + } + } + function unexportedRuntimeSymbol(sym) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get: function () { + var msg = + "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"; + if (isExportedByForceFilesystem(sym)) { + msg += + ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"; + } + abort(msg); + }, + }); + } + } + var wasmBinary; + if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; + legacyModuleProp("wasmBinary", "wasmBinary"); + var noExitRuntime = Module["noExitRuntime"] || true; + legacyModuleProp("noExitRuntime", "noExitRuntime"); + if (typeof WebAssembly != "object") { + abort("no native wasm support detected"); + } + var wasmMemory; + var ABORT = false; + var EXITSTATUS; + function assert(condition, text) { + if (!condition) { + abort("Assertion failed" + (text ? ": " + text : "")); + } + } + var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined; + function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ""; + while (idx < endPtr) { + var u0 = heapOrArray[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode(((u0 & 31) << 6) | u1); + continue; + } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 248) != 240) + warnOnce( + "Invalid UTF-8 leading byte " + + ptrToString(u0) + + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!", + ); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } + } + return str; + } + function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""; + } + function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = (65536 + ((u & 1023) << 10)) | (u1 & 1023); + } + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | (u >> 6); + heap[outIdx++] = 128 | (u & 63); + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | (u >> 12); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 1114111) + warnOnce( + "Invalid Unicode code point " + + ptrToString(u) + + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).", + ); + heap[outIdx++] = 240 | (u >> 18); + heap[outIdx++] = 128 | ((u >> 12) & 63); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + } + } + heap[outIdx] = 0; + return outIdx - startIdx; + } + function stringToUTF8(str, outPtr, maxBytesToWrite) { + assert( + typeof maxBytesToWrite == "number", + "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!", + ); + return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); + } + function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var c = str.charCodeAt(i); + if (c <= 127) { + len++; + } else if (c <= 2047) { + len += 2; + } else if (c >= 55296 && c <= 57343) { + len += 4; + ++i; + } else { + len += 3; + } + } + return len; + } + var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module["HEAP8"] = HEAP8 = new Int8Array(buf); + Module["HEAP16"] = HEAP16 = new Int16Array(buf); + Module["HEAP32"] = HEAP32 = new Int32Array(buf); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf); + Module["HEAPF32"] = HEAPF32 = new Float32Array(buf); + Module["HEAPF64"] = HEAPF64 = new Float64Array(buf); + } + var STACK_SIZE = 65536; + if (Module["STACK_SIZE"]) + assert( + STACK_SIZE === Module["STACK_SIZE"], + "the stack size can no longer be determined at runtime", + ); + var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216; + legacyModuleProp("INITIAL_MEMORY", "INITIAL_MEMORY"); + assert( + INITIAL_MEMORY >= STACK_SIZE, + "INITIAL_MEMORY should be larger than STACK_SIZE, was " + + INITIAL_MEMORY + + "! (STACK_SIZE=" + + STACK_SIZE + + ")", + ); + assert( + typeof Int32Array != "undefined" && + typeof Float64Array !== "undefined" && + Int32Array.prototype.subarray != undefined && + Int32Array.prototype.set != undefined, + "JS engine does not provide full typed array support", + ); + assert( + !Module["wasmMemory"], + "Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally", + ); + assert( + INITIAL_MEMORY == 16777216, + "Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically", + ); + var wasmTable; + function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + if (max == 0) { + max += 4; + } + HEAPU32[max >> 2] = 34821223; + HEAPU32[(max + 4) >> 2] = 2310721022; + HEAPU32[0] = 1668509029; + } + function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + if (max == 0) { + max += 4; + } + var cookie1 = HEAPU32[max >> 2]; + var cookie2 = HEAPU32[(max + 4) >> 2]; + if (cookie1 != 34821223 || cookie2 != 2310721022) { + abort( + "Stack overflow! Stack cookie has been overwritten at " + + ptrToString(max) + + ", expected hex dwords 0x89BACDFE and 0x2135467, but received " + + ptrToString(cookie2) + + " " + + ptrToString(cookie1), + ); + } + if (HEAPU32[0] !== 1668509029) { + abort("Runtime error: The application has corrupted its heap memory area (address zero)!"); + } + } + (function () { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 25459; + if (h8[0] !== 115 || h8[1] !== 99) + throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)"; + })(); + var __ATPRERUN__ = []; + var __ATINIT__ = []; + var __ATEXIT__ = []; + var __ATPOSTRUN__ = []; + var runtimeInitialized = false; + function keepRuntimeAlive() { + return noExitRuntime; + } + function preRun() { + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); + } + function initRuntime() { + assert(!runtimeInitialized); + runtimeInitialized = true; + checkStackCookie(); + if (!Module["noFSInit"] && !FS.init.initialized) FS.init(); + FS.ignorePermissions = false; + TTY.init(); + callRuntimeCallbacks(__ATINIT__); + } + function postRun() { + checkStackCookie(); + if (Module["postRun"]) { + if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]]; + while (Module["postRun"].length) { + addOnPostRun(Module["postRun"].shift()); + } + } + callRuntimeCallbacks(__ATPOSTRUN__); + } + function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); + } + function addOnInit(cb) { + __ATINIT__.unshift(cb); + } + function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); + } + assert( + Math.imul, + "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill", + ); + assert( + Math.fround, + "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill", + ); + assert( + Math.clz32, + "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill", + ); + assert( + Math.trunc, + "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill", + ); + var runDependencies = 0; + var runDependencyWatcher = null; + var dependenciesFulfilled = null; + var runDependencyTracking = {}; + function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } + } + function addRunDependency(id) { + runDependencies++; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != "undefined") { + runDependencyWatcher = setInterval(function () { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + err("still waiting on run dependencies:"); + } + err("dependency: " + dep); + } + if (shown) { + err("(end of list)"); + } + }, 1e4); + } + } else { + err("warning: run dependency added without ID"); + } + } + function removeRunDependency(id) { + runDependencies--; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + err("warning: run dependency removed without ID"); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } + } + function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what); + } + what = "Aborted(" + what + ")"; + err(what); + ABORT = true; + EXITSTATUS = 1; + var e = new WebAssembly.RuntimeError(what); + readyPromiseReject(e); + throw e; + } + var dataURIPrefix = "data:application/octet-stream;base64,"; + function isDataURI(filename) { + return filename.startsWith(dataURIPrefix); + } + function isFileURI(filename) { + return filename.startsWith("file://"); + } + function createExportWrapper(name, fixedasm) { + return function () { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module["asm"]; + } + assert( + runtimeInitialized, + "native function `" + displayName + "` called before runtime initialization", + ); + if (!asm[name]) { + assert(asm[name], "exported native function `" + displayName + "` not found"); + } + return asm[name].apply(null, arguments); + }; + } + var wasmBinaryFile; + wasmBinaryFile = "selfie_segmentation_solution_simd_wasm_bin.wasm"; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw "both async and sync fetching of the wasm failed"; + } catch (err) { + abort(err); + } + } + function getBinaryPromise() { + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == "function" && !isFileURI(wasmBinaryFile)) { + return fetch(wasmBinaryFile, { credentials: "same-origin" }) + .then(function (response) { + if (!response["ok"]) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response["arrayBuffer"](); + }) + .catch(function () { + return getBinary(wasmBinaryFile); + }); + } else { + if (readAsync) { + return new Promise(function (resolve, reject) { + readAsync( + wasmBinaryFile, + function (response) { + resolve(new Uint8Array(response)); + }, + reject, + ); + }); + } + } + } + return Promise.resolve().then(function () { + return getBinary(wasmBinaryFile); + }); + } + function createWasm() { + var info = { env: asmLibraryArg, wasi_snapshot_preview1: asmLibraryArg }; + function receiveInstance(instance, module) { + var exports = instance.exports; + Module["asm"] = exports; + wasmMemory = Module["asm"]["memory"]; + assert(wasmMemory, "memory not found in wasm exports"); + updateGlobalBufferAndViews(wasmMemory.buffer); + wasmTable = Module["asm"]["__indirect_function_table"]; + assert(wasmTable, "table not found in wasm exports"); + addOnInit(Module["asm"]["__wasm_call_ctors"]); + removeRunDependency("wasm-instantiate"); + } + addRunDependency("wasm-instantiate"); + var trueModule = Module; + function receiveInstantiationResult(result) { + assert( + Module === trueModule, + "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?", + ); + trueModule = null; + receiveInstance(result["instance"]); + } + function instantiateArrayBuffer(receiver) { + return getBinaryPromise() + .then(function (binary) { + return WebAssembly.instantiate(binary, info); + }) + .then(function (instance) { + return instance; + }) + .then(receiver, function (reason) { + err("failed to asynchronously prepare wasm: " + reason); + if (isFileURI(wasmBinaryFile)) { + err( + "warning: Loading from a file URI (" + + wasmBinaryFile + + ") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing", + ); + } + abort(reason); + }); + } + function instantiateAsync() { + if ( + !wasmBinary && + typeof WebAssembly.instantiateStreaming == "function" && + !isDataURI(wasmBinaryFile) && + !isFileURI(wasmBinaryFile) && + !ENVIRONMENT_IS_NODE && + typeof fetch == "function" + ) { + return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, info); + return result.then(receiveInstantiationResult, function (reason) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + return instantiateArrayBuffer(receiveInstantiationResult); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiationResult); + } + } + if (Module["instantiateWasm"]) { + try { + var exports = Module["instantiateWasm"](info, receiveInstance); + return exports; + } catch (e) { + err("Module.instantiateWasm callback failed with error: " + e); + readyPromiseReject(e); + } + } + instantiateAsync().catch(readyPromiseReject); + return {}; + } + var tempDouble; + var tempI64; + var ASM_CONSTS = { + 512548: ($0) => { + const canvas = Emval.toValue($0); + const context = canvas.getContext("webgpu"); + return JsValStore.add(context.getCurrentTexture()); + }, + 512683: ($0, $1, $2, $3, $4) => { + const drawable = Emval.toValue($0); + const device = JsValStore.get($1); + const texture = JsValStore.get($2); + const width = $3; + const height = $4; + device.queue.copyExternalImageToTexture({ source: drawable }, { texture: texture }, [ + width, + height, + ]); + }, + 512934: ($0, $1, $2, $3) => { + const sourceExtTex = Emval.toValue($0); + const device = JsValStore.get($1); + const sampler = JsValStore.get($2); + const bgLayout = JsValStore.get($3); + const bindGroup = device.createBindGroup({ + layout: bgLayout, + entries: [ + { binding: 0, resource: sampler }, + { binding: 1, resource: sourceExtTex }, + ], + }); + return JsValStore.add(bindGroup); + }, + 513282: ($0, $1) => { + const inputArray = Emval.toValue($0); + const output = Emval.toValue($1); + const ctx = output.getContext("2d"); + const image_data = new ImageData(inputArray, output.width, output.height); + ctx.putImageData(image_data, 0, 0); + }, + 513506: ($0, $1) => { + const input = Emval.toValue($0); + const outputArray = Emval.toValue($1); + const ctx = input.getContext("2d"); + const data = ctx.getImageData(0, 0, input.width, input.height); + outputArray.set(data.data); + }, + 513710: ($0, $1) => { + const input = Emval.toValue($0); + const output = Emval.toValue($1); + const ctx = output.getContext("2d"); + ctx.drawImage(input, 0, 0); + }, + 513846: () => { + return !!Module["preinitializedWebGPUDevice"]; + }, + 513897: () => { + let init_once = true; + if (init_once) { + const cachedFindCanvasEventTarget = findCanvasEventTarget; + if (typeof cachedFindCanvasEventTarget !== "function") { + if (typeof console !== "undefined") { + console.error( + "Expected Emscripten global function " + + '"findCanvasEventTarget" not found. WebGL context creation ' + + "may fail.", + ); + } + return; + } + findCanvasEventTarget = function (target) { + if (target == 0) { + if (Module && Module.canvas) { + return Module.canvas; + } else if (Module && Module.canvasCssSelector) { + return cachedFindCanvasEventTarget(Module.canvasCssSelector); + } + if (typeof console !== "undefined") { + console.warn( + "Module properties canvas and canvasCssSelector not " + + "found during WebGL context creation.", + ); + } + } + return cachedFindCanvasEventTarget(target); + }; + init_once = false; + } + }, + 514682: () => { + return typeof wasmOffsetConverter !== "undefined"; + }, + }; + function mediapipe_import_external_texture(device_handle, source_handle) { + const device = WebGPU.mgrDevice.get(device_handle); + const source = Emval.toValue(source_handle); + const externalTexture = device.importExternalTexture({ source: source }); + return Emval.toHandle(externalTexture); + } + function mediapipe_create_utility_canvas2d() { + const canvas = document.createElement("canvas"); + canvas.style.display = "none"; + canvas.id = "canvas_2d"; + document.body.appendChild(canvas); + return Emval.toHandle(canvas); + } + function HaveOffsetConverter() { + return typeof wasmOffsetConverter !== "undefined"; + } + function _emscripten_set_main_loop_timing(mode, value) { + Browser.mainLoop.timingMode = mode; + Browser.mainLoop.timingValue = value; + if (!Browser.mainLoop.func) { + err( + "emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up.", + ); + return 1; + } + if (!Browser.mainLoop.running) { + Browser.mainLoop.running = true; + } + if (mode == 0) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() { + var timeUntilNextTick = + Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now()) | 0; + setTimeout(Browser.mainLoop.runner, timeUntilNextTick); + }; + Browser.mainLoop.method = "timeout"; + } else if (mode == 1) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() { + Browser.requestAnimationFrame(Browser.mainLoop.runner); + }; + Browser.mainLoop.method = "rAF"; + } else if (mode == 2) { + if (typeof setImmediate == "undefined") { + var setImmediates = []; + var emscriptenMainLoopMessageId = "setimmediate"; + var Browser_setImmediate_messageHandler = (event) => { + if ( + event.data === emscriptenMainLoopMessageId || + event.data.target === emscriptenMainLoopMessageId + ) { + event.stopPropagation(); + setImmediates.shift()(); + } + }; + addEventListener("message", Browser_setImmediate_messageHandler, true); + setImmediate = function Browser_emulated_setImmediate(func) { + setImmediates.push(func); + if (ENVIRONMENT_IS_WORKER) { + if (Module["setImmediates"] === undefined) Module["setImmediates"] = []; + Module["setImmediates"].push(func); + postMessage({ target: emscriptenMainLoopMessageId }); + } else postMessage(emscriptenMainLoopMessageId, "*"); + }; + } + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() { + setImmediate(Browser.mainLoop.runner); + }; + Browser.mainLoop.method = "immediate"; + } + return 0; + } + var _emscripten_get_now; + if (ENVIRONMENT_IS_NODE) { + _emscripten_get_now = () => { + var t = process["hrtime"](); + return t[0] * 1e3 + t[1] / 1e6; + }; + } else _emscripten_get_now = () => performance.now(); + function _emscripten_webgl_do_commit_frame() { + if (!GL.currentContext || !GL.currentContext.GLctx) { + return -3; + } + if (GL.currentContext.defaultFbo) { + GL.blitOffscreenFramebuffer(GL.currentContext); + return 0; + } + if (!GL.currentContext.attributes.explicitSwapControl) { + return -3; + } + return 0; + } + function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; + } + var PATH = { + isAbs: (path) => path.charAt(0) === "/", + splitPath: (filename) => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^/]+?|)(\.[^./]*|))(?:[/]*)$/; + return splitPathRe.exec(filename).slice(1); + }, + normalizeArray: (parts, allowAboveRoot) => { + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === ".") { + parts.splice(i, 1); + } else if (last === "..") { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift(".."); + } + } + return parts; + }, + normalize: (path) => { + var isAbsolute = PATH.isAbs(path), + trailingSlash = path.substr(-1) === "/"; + path = PATH.normalizeArray( + path.split("/").filter((p) => !!p), + !isAbsolute, + ).join("/"); + if (!path && !isAbsolute) { + path = "."; + } + if (path && trailingSlash) { + path += "/"; + } + return (isAbsolute ? "/" : "") + path; + }, + dirname: (path) => { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + return "."; + } + if (dir) { + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }, + basename: (path) => { + if (path === "/") return "/"; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf("/"); + if (lastSlash === -1) return path; + return path.substr(lastSlash + 1); + }, + join: function () { + var paths = Array.prototype.slice.call(arguments); + return PATH.normalize(paths.join("/")); + }, + join2: (l, r) => { + return PATH.normalize(l + "/" + r); + }, + }; + function getRandomDevice() { + if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") { + var randomBuffer = new Uint8Array(1); + return () => { + crypto.getRandomValues(randomBuffer); + return randomBuffer[0]; + }; + } else if (ENVIRONMENT_IS_NODE) { + try { + var crypto_module = require("crypto"); + return () => crypto_module["randomBytes"](1)[0]; + } catch (e) {} + } + return () => + abort( + "no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };", + ); + } + var PATH_FS = { + resolve: function () { + var resolvedPath = "", + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = i >= 0 ? arguments[i] : FS.cwd(); + if (typeof path != "string") { + throw new TypeError("Arguments to path.resolve must be strings"); + } else if (!path) { + return ""; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = PATH.isAbs(path); + } + resolvedPath = PATH.normalizeArray( + resolvedPath.split("/").filter((p) => !!p), + !resolvedAbsolute, + ).join("/"); + return (resolvedAbsolute ? "/" : "") + resolvedPath || "."; + }, + relative: (from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== "") break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== "") break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split("/")); + var toParts = trim(to.split("/")); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push(".."); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join("/"); + }, + }; + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; + } + var TTY = { + ttys: [], + init: function () {}, + shutdown: function () {}, + register: function (dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + }, + stream_ops: { + open: function (stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + }, + close: function (stream) { + stream.tty.ops.fsync(stream.tty); + }, + fsync: function (stream) { + stream.tty.ops.fsync(stream.tty); + }, + read: function (stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset + i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: function (stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset + i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }, + }, + default_tty_ops: { + get_char: function (tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + try { + bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1); + } catch (e) { + if (e.toString().includes("EOF")) bytesRead = 0; + else throw e; + } + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString("utf-8"); + } else { + result = null; + } + } else if (typeof window != "undefined" && typeof window.prompt == "function") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n"; + } + } else if (typeof readline == "function") { + result = readline(); + if (result !== null) { + result += "\n"; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + }, + put_char: function (tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }, + fsync: function (tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }, + }, + default_tty1_ops: { + put_char: function (tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }, + fsync: function (tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }, + }, + }; + function zeroMemory(address, size) { + HEAPU8.fill(0, address, address + size); + return address; + } + function alignMemory(size, alignment) { + assert(alignment, "alignment argument is required"); + return Math.ceil(size / alignment) * alignment; + } + function mmapAlloc(size) { + size = alignMemory(size, 65536); + var ptr = _emscripten_builtin_memalign(65536, size); + if (!ptr) return 0; + return zeroMemory(ptr, size); + } + var MEMFS = { + ops_table: null, + mount: function (mount) { + return MEMFS.createNode(null, "/", 16384 | 511, 0); + }, + createNode: function (parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + throw new FS.ErrnoError(63); + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink, + }, + stream: { llseek: MEMFS.stream_ops.llseek }, + }, + file: { + node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync, + }, + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink, + }, + stream: {}, + }, + chrdev: { + node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, + stream: FS.chrdev_stream_ops, + }, + }; + } + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {}; + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; + node.contents = null; + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream; + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream; + } + node.timestamp = Date.now(); + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + }, + getFileDataAsTypedArray: function (node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); + return new Uint8Array(node.contents); + }, + expandFileStorage: function (node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max( + newCapacity, + (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125)) >>> 0, + ); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); + }, + resizeFileStorage: function (node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; + node.usedBytes = 0; + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); + } + node.usedBytes = newSize; + } + }, + node_ops: { + getattr: function (node) { + var attr = {}; + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes; + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length; + } else { + attr.size = 0; + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + }, + setattr: function (node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + }, + lookup: function (parent, name) { + throw FS.genericErrors[44]; + }, + mknod: function (parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + }, + rename: function (old_node, new_dir, new_name) { + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now(); + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + }, + unlink: function (parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + rmdir: function (parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + readdir: function (node) { + var entries = [".", ".."]; + for (var key in node.contents) { + if (!Object.hasOwn(node.contents, key)) { + continue; + } + entries.push(key); + } + return entries; + }, + symlink: function (parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); + node.link = oldpath; + return node; + }, + readlink: function (node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }, + }, + stream_ops: { + read: function (stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) return 0; + var size = Math.min(stream.node.usedBytes - position, length); + assert(size >= 0); + if (size > 8 && contents.subarray) { + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + }, + write: function (stream, buffer, offset, length, position, canOwn) { + assert(!(buffer instanceof ArrayBuffer)); + if (buffer.buffer === HEAP8.buffer) { + canOwn = false; + } + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + if (canOwn) { + assert(position === 0, "canOwn must imply no weird position inside the file"); + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer.subarray) { + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + }, + llseek: function (stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes; + } + } + if (position < 0) { + throw new FS.ErrnoError(28); + } + return position; + }, + allocate: function (stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + }, + mmap: function (stream, length, position, prot, flags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + if (!(flags & 2) && contents.buffer === buffer) { + allocated = false; + ptr = contents.byteOffset; + } else { + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.set(contents, ptr); + } + return { ptr: ptr, allocated: allocated }; + }, + msync: function (stream, buffer, offset, length, mmapFlags) { + MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + return 0; + }, + }, + }; + function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency("al " + url) : ""; + readAsync( + url, + (arrayBuffer) => { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, + (event) => { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + }, + ); + if (dep) addRunDependency(dep); + } + var ERRNO_MESSAGES = { + 0: "Success", + 1: "Arg list too long", + 2: "Permission denied", + 3: "Address already in use", + 4: "Address not available", + 5: "Address family not supported by protocol family", + 6: "No more processes", + 7: "Socket already connected", + 8: "Bad file number", + 9: "Trying to read unreadable message", + 10: "Mount device busy", + 11: "Operation canceled", + 12: "No children", + 13: "Connection aborted", + 14: "Connection refused", + 15: "Connection reset by peer", + 16: "File locking deadlock error", + 17: "Destination address required", + 18: "Math arg out of domain of func", + 19: "Quota exceeded", + 20: "File exists", + 21: "Bad address", + 22: "File too large", + 23: "Host is unreachable", + 24: "Identifier removed", + 25: "Illegal byte sequence", + 26: "Connection already in progress", + 27: "Interrupted system call", + 28: "Invalid argument", + 29: "I/O error", + 30: "Socket is already connected", + 31: "Is a directory", + 32: "Too many symbolic links", + 33: "Too many open files", + 34: "Too many links", + 35: "Message too long", + 36: "Multihop attempted", + 37: "File or path name too long", + 38: "Network interface is not configured", + 39: "Connection reset by network", + 40: "Network is unreachable", + 41: "Too many open files in system", + 42: "No buffer space available", + 43: "No such device", + 44: "No such file or directory", + 45: "Exec format error", + 46: "No record locks available", + 47: "The link has been severed", + 48: "Not enough core", + 49: "No message of desired type", + 50: "Protocol not available", + 51: "No space left on device", + 52: "Function not implemented", + 53: "Socket is not connected", + 54: "Not a directory", + 55: "Directory not empty", + 56: "State not recoverable", + 57: "Socket operation on non-socket", + 59: "Not a typewriter", + 60: "No such device or address", + 61: "Value too large for defined data type", + 62: "Previous owner died", + 63: "Not super-user", + 64: "Broken pipe", + 65: "Protocol error", + 66: "Unknown protocol", + 67: "Protocol wrong type for socket", + 68: "Math result not representable", + 69: "Read only file system", + 70: "Illegal seek", + 71: "No such process", + 72: "Stale file handle", + 73: "Connection timed out", + 74: "Text file busy", + 75: "Cross-device link", + 100: "Device not a stream", + 101: "Bad font file fmt", + 102: "Invalid slot", + 103: "Invalid request code", + 104: "No anode", + 105: "Block device required", + 106: "Channel number out of range", + 107: "Level 3 halted", + 108: "Level 3 reset", + 109: "Link number out of range", + 110: "Protocol driver not attached", + 111: "No CSI structure available", + 112: "Level 2 halted", + 113: "Invalid exchange", + 114: "Invalid request descriptor", + 115: "Exchange full", + 116: "No data (for no delay io)", + 117: "Timer expired", + 118: "Out of streams resources", + 119: "Machine is not on the network", + 120: "Package not installed", + 121: "The object is remote", + 122: "Advertise error", + 123: "Srmount error", + 124: "Communication error on send", + 125: "Cross mount point (not really error)", + 126: "Given log. name not unique", + 127: "f.d. invalid for this operation", + 128: "Remote address changed", + 129: "Can access a needed shared lib", + 130: "Accessing a corrupted shared lib", + 131: ".lib section in a.out corrupted", + 132: "Attempting to link in too many libs", + 133: "Attempting to exec a shared library", + 135: "Streams pipe error", + 136: "Too many users", + 137: "Socket type not supported", + 138: "Not supported", + 139: "Protocol family not supported", + 140: "Can't send after socket shutdown", + 141: "Too many references", + 142: "Host is down", + 148: "No medium (in tape drive)", + 156: "Level 2 not synchronized", + }; + var ERRNO_CODES = {}; + function demangle(func) { + warnOnce("warning: build with -sDEMANGLE_SUPPORT to link in libcxxabi demangling"); + return func; + } + function demangleAll(text) { + var regex = /\b_Z[\w\d_]+/g; + return text.replace(regex, function (x) { + var y = demangle(x); + return x === y ? x : y + " [" + x + "]"; + }); + } + var FS = { + root: null, + mounts: [], + devices: {}, + streams: [], + nextInode: 1, + nameTable: null, + currentPath: "/", + initialized: false, + ignorePermissions: true, + ErrnoError: null, + genericErrors: {}, + filesystems: null, + syncFSRequests: 0, + lookupPath: (path, opts = {}) => { + path = PATH_FS.resolve(path); + if (!path) return { path: "", node: null }; + var defaults = { follow_mount: true, recurse_count: 0 }; + opts = Object.assign(defaults, opts); + if (opts.recurse_count > 8) { + throw new FS.ErrnoError(32); + } + var parts = path.split("/").filter((p) => !!p); + var current = FS.root; + var current_path = "/"; + for (var i = 0; i < parts.length; i++) { + var islast = i === parts.length - 1; + if (islast && opts.parent) { + break; + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 }); + current = lookup.node; + if (count++ > 40) { + throw new FS.ErrnoError(32); + } + } + } + } + return { path: current_path, node: current }; + }, + getPath: (node) => { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path; + } + path = path ? node.name + "/" + path : node.name; + node = node.parent; + } + }, + hashName: (parentid, name) => { + var hash = 0; + for (var i = 0; i < name.length; i++) { + hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; + } + return ((parentid + hash) >>> 0) % FS.nameTable.length; + }, + hashAddNode: (node) => { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + }, + hashRemoveNode: (node) => { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + }, + lookupNode: (parent, name) => { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + return FS.lookup(parent, name); + }, + createNode: (parent, name, mode, rdev) => { + assert(typeof parent == "object"); + var node = new FS.FSNode(parent, name, mode, rdev); + FS.hashAddNode(node); + return node; + }, + destroyNode: (node) => { + FS.hashRemoveNode(node); + }, + isRoot: (node) => { + return node === node.parent; + }, + isMountpoint: (node) => { + return !!node.mounted; + }, + isFile: (mode) => { + return (mode & 61440) === 32768; + }, + isDir: (mode) => { + return (mode & 61440) === 16384; + }, + isLink: (mode) => { + return (mode & 61440) === 40960; + }, + isChrdev: (mode) => { + return (mode & 61440) === 8192; + }, + isBlkdev: (mode) => { + return (mode & 61440) === 24576; + }, + isFIFO: (mode) => { + return (mode & 61440) === 4096; + }, + isSocket: (mode) => { + return (mode & 49152) === 49152; + }, + flagModes: { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 }, + modeStringToFlags: (str) => { + var flags = FS.flagModes[str]; + if (typeof flags == "undefined") { + throw new Error("Unknown file open mode: " + str); + } + return flags; + }, + flagsToPermissionString: (flag) => { + var perms = ["r", "w", "rw"][flag & 3]; + if (flag & 512) { + perms += "w"; + } + return perms; + }, + nodePermissions: (node, perms) => { + if (FS.ignorePermissions) { + return 0; + } + if (perms.includes("r") && !(node.mode & 292)) { + return 2; + } else if (perms.includes("w") && !(node.mode & 146)) { + return 2; + } else if (perms.includes("x") && !(node.mode & 73)) { + return 2; + } + return 0; + }, + mayLookup: (dir) => { + var errCode = FS.nodePermissions(dir, "x"); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + }, + mayCreate: (dir, name) => { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) {} + return FS.nodePermissions(dir, "wx"); + }, + mayDelete: (dir, name, isdir) => { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, "wx"); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + }, + mayOpen: (node, flags) => { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) { + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + }, + MAX_OPEN_FDS: 4096, + nextfd: (fd_start = 0, fd_end = FS.MAX_OPEN_FDS) => { + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + }, + getStream: (fd) => FS.streams[fd], + createStream: (stream, fd_start, fd_end) => { + if (!FS.FSStream) { + FS.FSStream = function () { + this.shared = {}; + }; + FS.FSStream.prototype = {}; + Object.defineProperties(FS.FSStream.prototype, { + object: { + get: function () { + return this.node; + }, + set: function (val) { + this.node = val; + }, + }, + isRead: { + get: function () { + return (this.flags & 2097155) !== 1; + }, + }, + isWrite: { + get: function () { + return (this.flags & 2097155) !== 0; + }, + }, + isAppend: { + get: function () { + return this.flags & 1024; + }, + }, + flags: { + get: function () { + return this.shared.flags; + }, + set: function (val) { + this.shared.flags = val; + }, + }, + position: { + get: function () { + return this.shared.position; + }, + set: function (val) { + this.shared.position = val; + }, + }, + }); + } + stream = Object.assign(new FS.FSStream(), stream); + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + }, + closeStream: (fd) => { + FS.streams[fd] = null; + }, + chrdev_stream_ops: { + open: (stream) => { + var device = FS.getDevice(stream.node.rdev); + stream.stream_ops = device.stream_ops; + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + }, + llseek: () => { + throw new FS.ErrnoError(70); + }, + }, + major: (dev) => dev >> 8, + minor: (dev) => dev & 255, + makedev: (ma, mi) => (ma << 8) | mi, + registerDevice: (dev, ops) => { + FS.devices[dev] = { stream_ops: ops }; + }, + getDevice: (dev) => FS.devices[dev], + getMounts: (mount) => { + var mounts = []; + var check = [mount]; + while (check.length) { + var m = check.pop(); + mounts.push(m); + check.push.apply(check, m.mounts); + } + return mounts; + }, + syncfs: (populate, callback) => { + if (typeof populate == "function") { + callback = populate; + populate = false; + } + FS.syncFSRequests++; + if (FS.syncFSRequests > 1) { + err( + "warning: " + + FS.syncFSRequests + + " FS.syncfs operations in flight at once, probably just doing extra work", + ); + } + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + function doCallback(errCode) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(errCode); + } + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + } + mounts.forEach((mount) => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + }, + mount: (type, opts, mountpoint) => { + if (typeof type == "string") { + throw type; + } + var root = mountpoint === "/"; + var pseudo = !mountpoint; + var node; + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + mountpoint = lookup.path; + node = lookup.node; + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + var mount = { type: type, opts: opts, mountpoint: mountpoint, mounts: [] }; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot; + } else if (node) { + node.mounted = mount; + if (node.mount) { + node.mount.mounts.push(mount); + } + } + return mountRoot; + }, + unmount: (mountpoint) => { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + Object.keys(FS.nameTable).forEach((hash) => { + var current = FS.nameTable[hash]; + while (current) { + var next = current.name_next; + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + current = next; + } + }); + node.mounted = null; + var idx = node.mount.mounts.indexOf(mount); + assert(idx !== -1); + node.mount.mounts.splice(idx, 1); + }, + lookup: (parent, name) => { + return parent.node_ops.lookup(parent, name); + }, + mknod: (path, mode, dev) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === "." || name === "..") { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + }, + create: (path, mode) => { + mode = mode !== undefined ? mode : 438; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, + mkdir: (path, mode) => { + mode = mode !== undefined ? mode : 511; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + }, + mkdirTree: (path, mode) => { + var dirs = path.split("/"); + var d = ""; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += "/" + dirs[i]; + try { + FS.mkdir(d, mode); + } catch (e) { + if (e.errno != 20) throw e; + } + } + }, + mkdev: (path, mode, dev) => { + if (typeof dev == "undefined") { + dev = mode; + mode = 438; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + }, + symlink: (oldpath, newpath) => { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + }, + rename: (old_path, new_path) => { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + var lookup, old_dir, new_dir; + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(28); + } + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(55); + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (old_node === new_node) { + return; + } + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + errCode = new_node + ? FS.mayDelete(new_dir, new_name, isdir) + : FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + FS.hashAddNode(old_node); + } + }, + rmdir: (path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + }, + readdir: (path) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + }, + unlink: (path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + }, + readlink: (path) => { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + }, + stat: (path, dontFollow) => { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + }, + lstat: (path) => { + return FS.stat(path, true); + }, + chmod: (path, mode, dontFollow) => { + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now(), + }); + }, + lchmod: (path, mode) => { + FS.chmod(path, mode, true); + }, + fchmod: (fd, mode) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + }, + chown: (path, uid, gid, dontFollow) => { + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { timestamp: Date.now() }); + }, + lchown: (path, uid, gid) => { + FS.chown(path, uid, gid, true); + }, + fchown: (fd, uid, gid) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + }, + truncate: (path, len) => { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { size: len, timestamp: Date.now() }); + }, + ftruncate: (fd, len) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + }, + utime: (path, atime, mtime) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { timestamp: Math.max(atime, mtime) }); + }, + open: (path, flags, mode) => { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == "string" ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode == "undefined" ? 438 : mode; + if (flags & 64) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == "object") { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { follow: !(flags & 131072) }); + node = lookup.node; + } catch (e) {} + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(20); + } + } else { + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + if (flags & 512 && !created) { + FS.truncate(node, 0); + } + flags &= ~(128 | 512 | 131072); + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + ungotten: [], + error: false, + }); + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module["logReadFiles"] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + }, + close: (stream) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + }, + isClosed: (stream) => { + return stream.fd === null; + }, + llseek: (stream, offset, whence) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + }, + read: (stream, buffer, offset, length, position) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + }, + write: (stream, buffer, offset, length, position, canOwn) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + FS.llseek(stream, 0, 2); + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write( + stream, + buffer, + offset, + length, + position, + canOwn, + ); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + }, + allocate: (stream, offset, length) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + }, + mmap: (stream, length, position, prot, flags) => { + if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + }, + msync: (stream, buffer, offset, length, mmapFlags) => { + if (!stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + }, + munmap: (stream) => 0, + ioctl: (stream, cmd, arg) => { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + }, + readFile: (path, opts = {}) => { + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || "binary"; + if (opts.encoding !== "utf8" && opts.encoding !== "binary") { + throw new Error('Invalid encoding type "' + opts.encoding + '"'); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === "utf8") { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === "binary") { + ret = buf; + } + FS.close(stream); + return ret; + }, + writeFile: (path, data, opts = {}) => { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == "string") { + var buf = new Uint8Array(lengthBytesUTF8(data) + 1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error("Unsupported data type"); + } + FS.close(stream); + }, + cwd: () => FS.currentPath, + chdir: (path) => { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, "x"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + }, + createDefaultDirectories: () => { + FS.mkdir("/tmp"); + FS.mkdir("/home"); + FS.mkdir("/home/web_user"); + }, + createDefaultDevices: () => { + FS.mkdir("/dev"); + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length, + }); + FS.mkdev("/dev/null", FS.makedev(1, 3)); + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev("/dev/tty", FS.makedev(5, 0)); + FS.mkdev("/dev/tty1", FS.makedev(6, 0)); + var random_device = getRandomDevice(); + FS.createDevice("/dev", "random", random_device); + FS.createDevice("/dev", "urandom", random_device); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp"); + }, + createSpecialDirectories: () => { + FS.mkdir("/proc"); + var proc_self = FS.mkdir("/proc/self"); + FS.mkdir("/proc/self/fd"); + FS.mount( + { + mount: () => { + var node = FS.createNode(proc_self, "fd", 16384 | 511, 73); + node.node_ops = { + lookup: (parent, name) => { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { mountpoint: "fake" }, + node_ops: { readlink: () => stream.path }, + }; + ret.parent = ret; + return ret; + }, + }; + return node; + }, + }, + {}, + "/proc/self/fd", + ); + }, + createStandardStreams: () => { + if (Module["stdin"]) { + FS.createDevice("/dev", "stdin", Module["stdin"]); + } else { + FS.symlink("/dev/tty", "/dev/stdin"); + } + if (Module["stdout"]) { + FS.createDevice("/dev", "stdout", null, Module["stdout"]); + } else { + FS.symlink("/dev/tty", "/dev/stdout"); + } + if (Module["stderr"]) { + FS.createDevice("/dev", "stderr", null, Module["stderr"]); + } else { + FS.symlink("/dev/tty1", "/dev/stderr"); + } + var stdin = FS.open("/dev/stdin", 0); + var stdout = FS.open("/dev/stdout", 1); + var stderr = FS.open("/dev/stderr", 1); + assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")"); + assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")"); + assert(stderr.fd === 2, "invalid handle for stderr (" + stderr.fd + ")"); + }, + ensureErrnoError: () => { + if (FS.ErrnoError) return; + FS.ErrnoError = function ErrnoError(errno, node) { + this.node = node; + this.setErrno = function (errno) { + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + }; + this.setErrno(errno); + this.message = ERRNO_MESSAGES[errno]; + if (this.stack) { + Object.defineProperty(this, "stack", { value: new Error().stack, writable: true }); + this.stack = demangleAll(this.stack); + } + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + [44].forEach((code) => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ""; + }); + }, + staticInit: () => { + FS.ensureErrnoError(); + FS.nameTable = new Array(4096); + FS.mount(MEMFS, {}, "/"); + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + FS.filesystems = { MEMFS: MEMFS }; + }, + init: (input, output, error) => { + assert( + !FS.init.initialized, + "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)", + ); + FS.init.initialized = true; + FS.ensureErrnoError(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams(); + }, + quit: () => { + FS.init.initialized = false; + _fflush(0); + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + }, + getMode: (canRead, canWrite) => { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + }, + findObject: (path, dontResolveLastLink) => { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (!ret.exists) { + return null; + } + return ret.object; + }, + analyzePath: (path, dontResolveLastLink) => { + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) {} + var ret = { + isRoot: false, + exists: false, + error: 0, + name: null, + path: null, + object: null, + parentExists: false, + parentPath: null, + parentObject: null, + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === "/"; + } catch (e) { + ret.error = e.errno; + } + return ret; + }, + createPath: (parent, path, canRead, canWrite) => { + parent = typeof parent == "string" ? parent : FS.getPath(parent); + var parts = path.split("/").reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) {} + parent = current; + } + return current; + }, + createFile: (parent, name, properties, canRead, canWrite) => { + var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + }, + createDataFile: (parent, name, data, canRead, canWrite, canOwn) => { + var path = name; + if (parent) { + parent = typeof parent == "string" ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent; + } + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == "string") { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + }, + createDevice: (parent, name, input, output) => { + var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + FS.registerDevice(dev, { + open: (stream) => { + stream.seekable = false; + }, + close: (stream) => { + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: (stream, buffer, offset, length, pos) => { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset + i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: (stream, buffer, offset, length, pos) => { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset + i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }, + }); + return FS.mkdev(path, mode, dev); + }, + forceLoadFile: (obj) => { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest != "undefined") { + throw new Error( + "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.", + ); + } else if (read_) { + try { + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error("Cannot load without read() or XMLHttpRequest."); + } + }, + createLazyFile: (parent, name, url, canRead, canWrite) => { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; + } + LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { + if (idx > this.length - 1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize) | 0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + var xhr = new XMLHttpRequest(); + xhr.open("HEAD", url, false); + xhr.send(null); + if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304)) + throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = + (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + var chunkSize = 1024 * 1024; + if (!hasByteServing) chunkSize = datalength; + var doXHR = (from, to) => { + if (from > to) + throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength - 1) + throw new Error("only " + datalength + " bytes available! programmer error!"); + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + xhr.responseType = "arraybuffer"; + if (xhr.overrideMimeType) { + xhr.overrideMimeType("text/plain; charset=x-user-defined"); + } + xhr.send(null); + if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304)) + throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(xhr.response || []); + } + return intArrayFromString(xhr.responseText || "", true); + }; + + this.setDataGetter((chunkNum) => { + var start = chunkNum * chunkSize; + var end = (chunkNum + 1) * chunkSize - 1; + end = Math.min(end, datalength - 1); + if (typeof this.chunks[chunkNum] == "undefined") { + this.chunks[chunkNum] = doXHR(start, end); + } + if (typeof this.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!"); + return this.chunks[chunkNum]; + }); + if (usesGzip || !datalength) { + chunkSize = datalength = 1; + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest != "undefined") { + if (!ENVIRONMENT_IS_WORKER) + throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc"; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: function () { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + }, + }, + chunkSize: { + get: function () { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + }, + }, + }); + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + var node = FS.createFile(parent, name, properties, canRead, canWrite); + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + Object.defineProperties(node, { + usedBytes: { + get: function () { + return this.contents.length; + }, + }, + }); + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach((key) => { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + function writeChunks(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= contents.length) return 0; + var size = Math.min(contents.length - position, length); + assert(size >= 0); + if (contents.slice) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents.get(position + i); + } + } + return size; + } + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + return writeChunks(stream, buffer, offset, length, position); + }; + stream_ops.mmap = (stream, length, position, prot, flags) => { + FS.forceLoadFile(node); + var ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + writeChunks(stream, HEAP8, ptr, length, position); + return { ptr: ptr, allocated: true }; + }; + node.stream_ops = stream_ops; + return node; + }, + createPreloadedFile: ( + parent, + name, + url, + canRead, + canWrite, + onload, + onerror, + dontCreateFile, + canOwn, + preFinish, + ) => { + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency("cp " + fullname); + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + if ( + Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => { + if (onerror) onerror(); + removeRunDependency(dep); + }) + ) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == "string") { + asyncLoad(url, (byteArray) => processData(byteArray), onerror); + } else { + processData(url); + } + }, + indexedDB: () => { + return ( + window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB + ); + }, + DB_NAME: () => { + return "EM_FS_" + window.location.pathname; + }, + DB_VERSION: 20, + DB_STORE_NAME: "FILE_DATA", + saveFilesToDB: (paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = () => { + out("creating db"); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + openRequest.onsuccess = () => { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite"); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, + fail = 0, + total = paths.length; + function finish() { + if (fail == 0) onload(); + else onerror(); + } + paths.forEach((path) => { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = () => { + ok++; + if (ok + fail == total) finish(); + }; + putRequest.onerror = () => { + fail++; + if (ok + fail == total) finish(); + }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }, + loadFilesFromDB: (paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; + openRequest.onsuccess = () => { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], "readonly"); + } catch (e) { + onerror(e); + return; + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, + fail = 0, + total = paths.length; + function finish() { + if (fail == 0) onload(); + else onerror(); + } + paths.forEach((path) => { + var getRequest = files.get(path); + getRequest.onsuccess = () => { + if (FS.analyzePath(path).exists) { + FS.unlink(path); + } + FS.createDataFile( + PATH.dirname(path), + PATH.basename(path), + getRequest.result, + true, + true, + true, + ); + ok++; + if (ok + fail == total) finish(); + }; + getRequest.onerror = () => { + fail++; + if (ok + fail == total) finish(); + }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }, + absolutePath: () => { + abort("FS.absolutePath has been removed; use PATH_FS.resolve instead"); + }, + createFolder: () => { + abort("FS.createFolder has been removed; use FS.mkdir instead"); + }, + createLink: () => { + abort("FS.createLink has been removed; use FS.symlink instead"); + }, + joinPath: () => { + abort("FS.joinPath has been removed; use PATH.join instead"); + }, + mmapAlloc: () => { + abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc"); + }, + standardizePath: () => { + abort("FS.standardizePath has been removed; use PATH.normalize instead"); + }, + }; + var SYSCALLS = { + DEFAULT_POLLMASK: 5, + calculateAt: function (dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = SYSCALLS.getStreamFromFD(dirfd); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44); + } + return dir; + } + return PATH.join2(dir, path); + }, + doStat: function (func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + return -54; + } + throw e; + } + HEAP32[buf >> 2] = stat.dev; + HEAP32[(buf + 8) >> 2] = stat.ino; + HEAP32[(buf + 12) >> 2] = stat.mode; + HEAPU32[(buf + 16) >> 2] = stat.nlink; + HEAP32[(buf + 20) >> 2] = stat.uid; + HEAP32[(buf + 24) >> 2] = stat.gid; + HEAP32[(buf + 28) >> 2] = stat.rdev; + (tempI64 = [ + stat.size >>> 0, + ((tempDouble = stat.size), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 40) >> 2] = tempI64[0]), + (HEAP32[(buf + 44) >> 2] = tempI64[1]); + HEAP32[(buf + 48) >> 2] = 4096; + HEAP32[(buf + 52) >> 2] = stat.blocks; + (tempI64 = [ + Math.floor(stat.atime.getTime() / 1e3) >>> 0, + ((tempDouble = Math.floor(stat.atime.getTime() / 1e3)), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 56) >> 2] = tempI64[0]), + (HEAP32[(buf + 60) >> 2] = tempI64[1]); + HEAPU32[(buf + 64) >> 2] = 0; + (tempI64 = [ + Math.floor(stat.mtime.getTime() / 1e3) >>> 0, + ((tempDouble = Math.floor(stat.mtime.getTime() / 1e3)), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 72) >> 2] = tempI64[0]), + (HEAP32[(buf + 76) >> 2] = tempI64[1]); + HEAPU32[(buf + 80) >> 2] = 0; + (tempI64 = [ + Math.floor(stat.ctime.getTime() / 1e3) >>> 0, + ((tempDouble = Math.floor(stat.ctime.getTime() / 1e3)), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 88) >> 2] = tempI64[0]), + (HEAP32[(buf + 92) >> 2] = tempI64[1]); + HEAPU32[(buf + 96) >> 2] = 0; + (tempI64 = [ + stat.ino >>> 0, + ((tempDouble = stat.ino), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 104) >> 2] = tempI64[0]), + (HEAP32[(buf + 108) >> 2] = tempI64[1]); + return 0; + }, + doMsync: function (addr, stream, len, flags, offset) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (flags & 2) { + return 0; + } + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + }, + varargs: undefined, + get: function () { + assert(SYSCALLS.varargs != undefined); + SYSCALLS.varargs += 4; + var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2]; + return ret; + }, + getStr: function (ptr) { + var ret = UTF8ToString(ptr); + return ret; + }, + getStreamFromFD: function (fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream; + }, + }; + function _proc_exit(code) { + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + if (Module["onExit"]) Module["onExit"](code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); + } + function exitJS(status, implicit) { + EXITSTATUS = status; + checkUnflushedContent(); + if (keepRuntimeAlive() && !implicit) { + var msg = + "program exited (with status: " + + status + + "), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)"; + readyPromiseReject(msg); + err(msg); + } + _proc_exit(status); + } + var _exit = exitJS; + function handleException(e) { + if (e instanceof ExitStatus || e == "unwind") { + return EXITSTATUS; + } + checkStackCookie(); + if (e instanceof WebAssembly.RuntimeError) { + if (_emscripten_stack_get_current() <= 0) { + err( + "Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to " + + STACK_SIZE + + ")", + ); + } + } + quit_(1, e); + } + function maybeExit() {} + function setMainLoop(browserIterationFunc, fps, simulateInfiniteLoop, arg, noSetTiming) { + assert( + !Browser.mainLoop.func, + "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.", + ); + Browser.mainLoop.func = browserIterationFunc; + Browser.mainLoop.arg = arg; + var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop; + function checkIsRunning() { + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) { + maybeExit(); + return false; + } + return true; + } + Browser.mainLoop.running = false; + Browser.mainLoop.runner = function Browser_mainLoop_runner() { + if (ABORT) return; + if (Browser.mainLoop.queue.length > 0) { + var start = Date.now(); + var blocker = Browser.mainLoop.queue.shift(); + blocker.func(blocker.arg); + if (Browser.mainLoop.remainingBlockers) { + var remaining = Browser.mainLoop.remainingBlockers; + var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining); + if (blocker.counted) { + Browser.mainLoop.remainingBlockers = next; + } else { + next = next + 0.5; + Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9; + } + } + out('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + " ms"); + Browser.mainLoop.updateStatus(); + if (!checkIsRunning()) return; + setTimeout(Browser.mainLoop.runner, 0); + return; + } + if (!checkIsRunning()) return; + Browser.mainLoop.currentFrameNumber = (Browser.mainLoop.currentFrameNumber + 1) | 0; + if ( + Browser.mainLoop.timingMode == 1 && + Browser.mainLoop.timingValue > 1 && + Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0 + ) { + Browser.mainLoop.scheduler(); + return; + } else if (Browser.mainLoop.timingMode == 0) { + Browser.mainLoop.tickStartTime = _emscripten_get_now(); + } + GL.newRenderingFrameStarted(); + if ( + typeof GL != "undefined" && + GL.currentContext && + !GL.currentContextIsProxied && + !GL.currentContext.attributes.explicitSwapControl && + GL.currentContext.GLctx.commit + ) { + GL.currentContext.GLctx.commit(); + } + if (Browser.mainLoop.method === "timeout" && Module.ctx) { + warnOnce( + "Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!", + ); + Browser.mainLoop.method = ""; + } + Browser.mainLoop.runIter(browserIterationFunc); + checkStackCookie(); + if (!checkIsRunning()) return; + if (typeof SDL == "object" && SDL.audio && SDL.audio.queueNewAudioData) + SDL.audio.queueNewAudioData(); + Browser.mainLoop.scheduler(); + }; + if (!noSetTiming) { + if (fps && fps > 0) _emscripten_set_main_loop_timing(0, 1e3 / fps); + else _emscripten_set_main_loop_timing(1, 1); + Browser.mainLoop.scheduler(); + } + if (simulateInfiniteLoop) { + throw "unwind"; + } + } + function callUserCallback(func) { + if (ABORT) { + err("user callback triggered after runtime exited or application aborted. Ignoring."); + return; + } + try { + func(); + } catch (e) { + handleException(e); + } + } + function safeSetTimeout(func, timeout) { + return setTimeout(function () { + callUserCallback(func); + }, timeout); + } + function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + if (ENVIRONMENT_IS_NODE) text = "warning: " + text; + err(text); + } + } + var Browser = { + mainLoop: { + running: false, + scheduler: null, + method: "", + currentlyRunningMainloop: 0, + func: null, + arg: 0, + timingMode: 0, + timingValue: 0, + currentFrameNumber: 0, + queue: [], + pause: function () { + Browser.mainLoop.scheduler = null; + Browser.mainLoop.currentlyRunningMainloop++; + }, + resume: function () { + Browser.mainLoop.currentlyRunningMainloop++; + var timingMode = Browser.mainLoop.timingMode; + var timingValue = Browser.mainLoop.timingValue; + var func = Browser.mainLoop.func; + Browser.mainLoop.func = null; + setMainLoop(func, 0, false, Browser.mainLoop.arg, true); + _emscripten_set_main_loop_timing(timingMode, timingValue); + Browser.mainLoop.scheduler(); + }, + updateStatus: function () { + if (Module["setStatus"]) { + var message = Module["statusMessage"] || "Please wait..."; + var remaining = Browser.mainLoop.remainingBlockers; + var expected = Browser.mainLoop.expectedBlockers; + if (remaining) { + if (remaining < expected) { + Module["setStatus"](message + " (" + (expected - remaining) + "/" + expected + ")"); + } else { + Module["setStatus"](message); + } + } else { + Module["setStatus"](""); + } + } + }, + runIter: function (func) { + if (ABORT) return; + if (Module["preMainLoop"]) { + var preRet = Module["preMainLoop"](); + if (preRet === false) { + return; + } + } + callUserCallback(func); + if (Module["postMainLoop"]) Module["postMainLoop"](); + }, + }, + isFullscreen: false, + pointerLock: false, + moduleContextCreatedCallbacks: [], + workers: [], + init: function () { + if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; + if (Browser.initted) return; + Browser.initted = true; + try { + new Blob(); + Browser.hasBlobConstructor = true; + } catch (e) { + Browser.hasBlobConstructor = false; + err("warning: no blob constructor, cannot create blobs with mimetypes"); + } + Browser.BlobBuilder = + typeof MozBlobBuilder != "undefined" + ? MozBlobBuilder + : typeof WebKitBlobBuilder != "undefined" + ? WebKitBlobBuilder + : !Browser.hasBlobConstructor + ? err("warning: no BlobBuilder") + : null; + Browser.URLObject = + typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined; + if (!Module.noImageDecoding && typeof Browser.URLObject == "undefined") { + err( + "warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.", + ); + Module.noImageDecoding = true; + } + var imagePlugin = {}; + imagePlugin["canHandle"] = function imagePlugin_canHandle(name) { + return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name); + }; + imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) { + var b = null; + if (Browser.hasBlobConstructor) { + try { + b = new Blob([byteArray], { type: Browser.getMimetype(name) }); + if (b.size !== byteArray.length) { + b = new Blob([new Uint8Array(byteArray).buffer], { + type: Browser.getMimetype(name), + }); + } + } catch (e) { + warnOnce( + "Blob constructor present but fails: " + e + "; falling back to blob builder", + ); + } + } + if (!b) { + var bb = new Browser.BlobBuilder(); + bb.append(new Uint8Array(byteArray).buffer); + b = bb.getBlob(); + } + var url = Browser.URLObject.createObjectURL(b); + assert(typeof url == "string", "createObjectURL must return a url as a string"); + var img = new Image(); + img.onload = () => { + assert(img.complete, "Image " + name + " could not be decoded"); + var canvas = document.createElement("canvas"); + canvas.width = img.width; + canvas.height = img.height; + var ctx = canvas.getContext("2d"); + ctx.drawImage(img, 0, 0); + preloadedImages[name] = canvas; + Browser.URLObject.revokeObjectURL(url); + if (onload) onload(byteArray); + }; + img.onerror = (event) => { + out("Image " + url + " could not be decoded"); + if (onerror) onerror(); + }; + img.src = url; + }; + Module["preloadPlugins"].push(imagePlugin); + var audioPlugin = {}; + audioPlugin["canHandle"] = function audioPlugin_canHandle(name) { + return !Module.noAudioDecoding && name.substr(-4) in { ".ogg": 1, ".wav": 1, ".mp3": 1 }; + }; + audioPlugin["handle"] = function audioPlugin_handle(byteArray, name, onload, onerror) { + var done = false; + function finish(audio) { + if (done) return; + done = true; + preloadedAudios[name] = audio; + if (onload) onload(byteArray); + } + function fail() { + if (done) return; + done = true; + preloadedAudios[name] = new Audio(); + if (onerror) onerror(); + } + if (Browser.hasBlobConstructor) { + try { + var b = new Blob([byteArray], { type: Browser.getMimetype(name) }); + } catch (e) { + return fail(); + } + var url = Browser.URLObject.createObjectURL(b); + assert(typeof url == "string", "createObjectURL must return a url as a string"); + var audio = new Audio(); + audio.addEventListener("canplaythrough", () => finish(audio), false); + audio.onerror = function audio_onerror(event) { + if (done) return; + err( + "warning: browser could not fully decode audio " + + name + + ", trying slower base64 approach", + ); + function encode64(data) { + var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var PAD = "="; + var ret = ""; + var leftchar = 0; + var leftbits = 0; + for (var i = 0; i < data.length; i++) { + leftchar = (leftchar << 8) | data[i]; + leftbits += 8; + while (leftbits >= 6) { + var curr = (leftchar >> (leftbits - 6)) & 63; + leftbits -= 6; + ret += BASE[curr]; + } + } + if (leftbits == 2) { + ret += BASE[(leftchar & 3) << 4]; + ret += PAD + PAD; + } else if (leftbits == 4) { + ret += BASE[(leftchar & 15) << 2]; + ret += PAD; + } + return ret; + } + audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray); + finish(audio); + }; + audio.src = url; + safeSetTimeout(function () { + finish(audio); + }, 1e4); + } else { + return fail(); + } + }; + Module["preloadPlugins"].push(audioPlugin); + function pointerLockChange() { + Browser.pointerLock = + document["pointerLockElement"] === Module["canvas"] || + document["mozPointerLockElement"] === Module["canvas"] || + document["webkitPointerLockElement"] === Module["canvas"] || + document["msPointerLockElement"] === Module["canvas"]; + } + var canvas = Module["canvas"]; + if (canvas) { + canvas.requestPointerLock = + canvas["requestPointerLock"] || + canvas["mozRequestPointerLock"] || + canvas["webkitRequestPointerLock"] || + canvas["msRequestPointerLock"] || + (() => {}); + canvas.exitPointerLock = + document["exitPointerLock"] || + document["mozExitPointerLock"] || + document["webkitExitPointerLock"] || + document["msExitPointerLock"] || + (() => {}); + canvas.exitPointerLock = canvas.exitPointerLock.bind(document); + document.addEventListener("pointerlockchange", pointerLockChange, false); + document.addEventListener("mozpointerlockchange", pointerLockChange, false); + document.addEventListener("webkitpointerlockchange", pointerLockChange, false); + document.addEventListener("mspointerlockchange", pointerLockChange, false); + if (Module["elementPointerLock"]) { + canvas.addEventListener( + "click", + (ev) => { + if (!Browser.pointerLock && Module["canvas"].requestPointerLock) { + Module["canvas"].requestPointerLock(); + ev.preventDefault(); + } + }, + false, + ); + } + } + }, + handledByPreloadPlugin: function (byteArray, fullname, finish, onerror) { + Browser.init(); + var handled = false; + Module["preloadPlugins"].forEach(function (plugin) { + if (handled) return; + if (plugin["canHandle"](fullname)) { + plugin["handle"](byteArray, fullname, finish, onerror); + handled = true; + } + }); + return handled; + }, + createContext: function (canvas, useWebGL, setInModule, webGLContextAttributes) { + if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx; + var ctx; + var contextHandle; + if (useWebGL) { + var contextAttributes = { + antialias: false, + alpha: false, + majorVersion: typeof WebGL2RenderingContext != "undefined" ? 2 : 1, + }; + if (webGLContextAttributes) { + for (var attribute in webGLContextAttributes) { + contextAttributes[attribute] = webGLContextAttributes[attribute]; + } + } + if (typeof GL != "undefined") { + contextHandle = GL.createContext(canvas, contextAttributes); + if (contextHandle) { + ctx = GL.getContext(contextHandle).GLctx; + } + } + } else { + ctx = canvas.getContext("2d"); + } + if (!ctx) return null; + if (setInModule) { + if (!useWebGL) + assert( + typeof GLctx == "undefined", + "cannot set in module if GLctx is used, but we are a non-GL context that would replace it", + ); + Module.ctx = ctx; + if (useWebGL) GL.makeContextCurrent(contextHandle); + Module.useWebGL = useWebGL; + Browser.moduleContextCreatedCallbacks.forEach(function (callback) { + callback(); + }); + Browser.init(); + } + return ctx; + }, + destroyContext: function (canvas, useWebGL, setInModule) {}, + fullscreenHandlersInstalled: false, + lockPointer: undefined, + resizeCanvas: undefined, + requestFullscreen: function (lockPointer, resizeCanvas) { + Browser.lockPointer = lockPointer; + Browser.resizeCanvas = resizeCanvas; + if (typeof Browser.lockPointer == "undefined") Browser.lockPointer = true; + if (typeof Browser.resizeCanvas == "undefined") Browser.resizeCanvas = false; + var canvas = Module["canvas"]; + function fullscreenChange() { + Browser.isFullscreen = false; + var canvasContainer = canvas.parentNode; + if ( + (document["fullscreenElement"] || + document["mozFullScreenElement"] || + document["msFullscreenElement"] || + document["webkitFullscreenElement"] || + document["webkitCurrentFullScreenElement"]) === canvasContainer + ) { + canvas.exitFullscreen = Browser.exitFullscreen; + if (Browser.lockPointer) canvas.requestPointerLock(); + Browser.isFullscreen = true; + if (Browser.resizeCanvas) { + Browser.setFullscreenCanvasSize(); + } else { + Browser.updateCanvasDimensions(canvas); + } + } else { + canvasContainer.parentNode.insertBefore(canvas, canvasContainer); + canvasContainer.parentNode.removeChild(canvasContainer); + if (Browser.resizeCanvas) { + Browser.setWindowedCanvasSize(); + } else { + Browser.updateCanvasDimensions(canvas); + } + } + if (Module["onFullScreen"]) Module["onFullScreen"](Browser.isFullscreen); + if (Module["onFullscreen"]) Module["onFullscreen"](Browser.isFullscreen); + } + if (!Browser.fullscreenHandlersInstalled) { + Browser.fullscreenHandlersInstalled = true; + document.addEventListener("fullscreenchange", fullscreenChange, false); + document.addEventListener("mozfullscreenchange", fullscreenChange, false); + document.addEventListener("webkitfullscreenchange", fullscreenChange, false); + document.addEventListener("MSFullscreenChange", fullscreenChange, false); + } + var canvasContainer = document.createElement("div"); + canvas.parentNode.insertBefore(canvasContainer, canvas); + canvasContainer.appendChild(canvas); + canvasContainer.requestFullscreen = + canvasContainer["requestFullscreen"] || + canvasContainer["mozRequestFullScreen"] || + canvasContainer["msRequestFullscreen"] || + (canvasContainer["webkitRequestFullscreen"] + ? () => canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]) + : null) || + (canvasContainer["webkitRequestFullScreen"] + ? () => canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]) + : null); + canvasContainer.requestFullscreen(); + }, + requestFullScreen: function () { + abort( + "Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)", + ); + }, + exitFullscreen: function () { + if (!Browser.isFullscreen) { + return false; + } + var CFS = + document["exitFullscreen"] || + document["cancelFullScreen"] || + document["mozCancelFullScreen"] || + document["msExitFullscreen"] || + document["webkitCancelFullScreen"] || + function () {}; + CFS.apply(document, []); + return true; + }, + nextRAF: 0, + fakeRequestAnimationFrame: function (func) { + var now = Date.now(); + if (Browser.nextRAF === 0) { + Browser.nextRAF = now + 1e3 / 60; + } else { + while (now + 2 >= Browser.nextRAF) { + Browser.nextRAF += 1e3 / 60; + } + } + var delay = Math.max(Browser.nextRAF - now, 0); + setTimeout(func, delay); + }, + requestAnimationFrame: function (func) { + if (typeof requestAnimationFrame == "function") { + requestAnimationFrame(func); + return; + } + var RAF = Browser.fakeRequestAnimationFrame; + RAF(func); + }, + safeSetTimeout: function (func, timeout) { + return safeSetTimeout(func, timeout); + }, + safeRequestAnimationFrame: function (func) { + return Browser.requestAnimationFrame(function () { + callUserCallback(func); + }); + }, + getMimetype: function (name) { + return { + jpg: "image/jpeg", + jpeg: "image/jpeg", + png: "image/png", + bmp: "image/bmp", + ogg: "audio/ogg", + wav: "audio/wav", + mp3: "audio/mpeg", + }[name.substr(name.lastIndexOf(".") + 1)]; + }, + getUserMedia: function (func) { + if (!window.getUserMedia) { + window.getUserMedia = navigator["getUserMedia"] || navigator["mozGetUserMedia"]; + } + window.getUserMedia(func); + }, + getMovementX: function (event) { + return event["movementX"] || event["mozMovementX"] || event["webkitMovementX"] || 0; + }, + getMovementY: function (event) { + return event["movementY"] || event["mozMovementY"] || event["webkitMovementY"] || 0; + }, + getMouseWheelDelta: function (event) { + var delta = 0; + switch (event.type) { + case "DOMMouseScroll": + delta = event.detail / 3; + break; + case "mousewheel": + delta = event.wheelDelta / 120; + break; + case "wheel": + delta = event.deltaY; + switch (event.deltaMode) { + case 0: + delta /= 100; + break; + case 1: + delta /= 3; + break; + case 2: + delta *= 80; + break; + default: + throw "unrecognized mouse wheel delta mode: " + event.deltaMode; + } + break; + default: + throw "unrecognized mouse wheel event: " + event.type; + } + return delta; + }, + mouseX: 0, + mouseY: 0, + mouseMovementX: 0, + mouseMovementY: 0, + touches: {}, + lastTouches: {}, + calculateMouseEvent: function (event) { + if (Browser.pointerLock) { + if (event.type != "mousemove" && "mozMovementX" in event) { + Browser.mouseMovementX = Browser.mouseMovementY = 0; + } else { + Browser.mouseMovementX = Browser.getMovementX(event); + Browser.mouseMovementY = Browser.getMovementY(event); + } + if (typeof SDL != "undefined") { + Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; + Browser.mouseY = SDL.mouseY + Browser.mouseMovementY; + } else { + Browser.mouseX += Browser.mouseMovementX; + Browser.mouseY += Browser.mouseMovementY; + } + } else { + var rect = Module["canvas"].getBoundingClientRect(); + var cw = Module["canvas"].width; + var ch = Module["canvas"].height; + var scrollX = typeof window.scrollX != "undefined" ? window.scrollX : window.pageXOffset; + var scrollY = typeof window.scrollY != "undefined" ? window.scrollY : window.pageYOffset; + assert( + typeof scrollX != "undefined" && typeof scrollY != "undefined", + "Unable to retrieve scroll position, mouse positions likely broken.", + ); + if ( + event.type === "touchstart" || + event.type === "touchend" || + event.type === "touchmove" + ) { + var touch = event.touch; + if (touch === undefined) { + return; + } + var adjustedX = touch.pageX - (scrollX + rect.left); + var adjustedY = touch.pageY - (scrollY + rect.top); + adjustedX = adjustedX * (cw / rect.width); + adjustedY = adjustedY * (ch / rect.height); + var coords = { x: adjustedX, y: adjustedY }; + if (event.type === "touchstart") { + Browser.lastTouches[touch.identifier] = coords; + Browser.touches[touch.identifier] = coords; + } else if (event.type === "touchend" || event.type === "touchmove") { + var last = Browser.touches[touch.identifier]; + if (!last) last = coords; + Browser.lastTouches[touch.identifier] = last; + Browser.touches[touch.identifier] = coords; + } + return; + } + var x = event.pageX - (scrollX + rect.left); + var y = event.pageY - (scrollY + rect.top); + x = x * (cw / rect.width); + y = y * (ch / rect.height); + Browser.mouseMovementX = x - Browser.mouseX; + Browser.mouseMovementY = y - Browser.mouseY; + Browser.mouseX = x; + Browser.mouseY = y; + } + }, + resizeListeners: [], + updateResizeListeners: function () { + var canvas = Module["canvas"]; + Browser.resizeListeners.forEach(function (listener) { + listener(canvas.width, canvas.height); + }); + }, + setCanvasSize: function (width, height, noUpdates) { + var canvas = Module["canvas"]; + Browser.updateCanvasDimensions(canvas, width, height); + if (!noUpdates) Browser.updateResizeListeners(); + }, + windowedWidth: 0, + windowedHeight: 0, + setFullscreenCanvasSize: function () { + if (typeof SDL != "undefined") { + var flags = HEAPU32[SDL.screen >> 2]; + flags = flags | 8388608; + HEAP32[SDL.screen >> 2] = flags; + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners(); + }, + setWindowedCanvasSize: function () { + if (typeof SDL != "undefined") { + var flags = HEAPU32[SDL.screen >> 2]; + flags = flags & ~8388608; + HEAP32[SDL.screen >> 2] = flags; + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners(); + }, + updateCanvasDimensions: function (canvas, wNative, hNative) { + if (wNative && hNative) { + canvas.widthNative = wNative; + canvas.heightNative = hNative; + } else { + wNative = canvas.widthNative; + hNative = canvas.heightNative; + } + var w = wNative; + var h = hNative; + if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) { + if (w / h < Module["forcedAspectRatio"]) { + w = Math.round(h * Module["forcedAspectRatio"]); + } else { + h = Math.round(w / Module["forcedAspectRatio"]); + } + } + if ( + (document["fullscreenElement"] || + document["mozFullScreenElement"] || + document["msFullscreenElement"] || + document["webkitFullscreenElement"] || + document["webkitCurrentFullScreenElement"]) === canvas.parentNode && + typeof screen != "undefined" + ) { + var factor = Math.min(screen.width / w, screen.height / h); + w = Math.round(w * factor); + h = Math.round(h * factor); + } + if (Browser.resizeCanvas) { + if (canvas.width != w) canvas.width = w; + if (canvas.height != h) canvas.height = h; + if (typeof canvas.style != "undefined") { + canvas.style.removeProperty("width"); + canvas.style.removeProperty("height"); + } + } else { + if (canvas.width != wNative) canvas.width = wNative; + if (canvas.height != hNative) canvas.height = hNative; + if (typeof canvas.style != "undefined") { + if (w != wNative || h != hNative) { + canvas.style.setProperty("width", w + "px", "important"); + canvas.style.setProperty("height", h + "px", "important"); + } else { + canvas.style.removeProperty("width"); + canvas.style.removeProperty("height"); + } + } + } + }, + }; + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + callbacks.shift()(Module); + } + } + function ptrToString(ptr) { + return "0x" + ptr.toString(16).padStart(8, "0"); + } + function ___assert_fail(condition, filename, line, func) { + abort( + "Assertion failed: " + + UTF8ToString(condition) + + ", at: " + + [ + filename ? UTF8ToString(filename) : "unknown filename", + line, + func ? UTF8ToString(func) : "unknown function", + ], + ); + } + function ___cxa_allocate_exception(size) { + return _malloc(size + 24) + 24; + } + function ExceptionInfo(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 24; + this.set_type = function (type) { + HEAPU32[(this.ptr + 4) >> 2] = type; + }; + this.get_type = function () { + return HEAPU32[(this.ptr + 4) >> 2]; + }; + this.set_destructor = function (destructor) { + HEAPU32[(this.ptr + 8) >> 2] = destructor; + }; + this.get_destructor = function () { + return HEAPU32[(this.ptr + 8) >> 2]; + }; + this.set_refcount = function (refcount) { + HEAP32[this.ptr >> 2] = refcount; + }; + this.set_caught = function (caught) { + caught = caught ? 1 : 0; + HEAP8[(this.ptr + 12) >> 0] = caught; + }; + this.get_caught = function () { + return HEAP8[(this.ptr + 12) >> 0] != 0; + }; + this.set_rethrown = function (rethrown) { + rethrown = rethrown ? 1 : 0; + HEAP8[(this.ptr + 13) >> 0] = rethrown; + }; + this.get_rethrown = function () { + return HEAP8[(this.ptr + 13) >> 0] != 0; + }; + this.init = function (type, destructor) { + this.set_adjusted_ptr(0); + this.set_type(type); + this.set_destructor(destructor); + this.set_refcount(0); + this.set_caught(false); + this.set_rethrown(false); + }; + this.add_ref = function () { + var value = HEAP32[this.ptr >> 2]; + HEAP32[this.ptr >> 2] = value + 1; + }; + this.release_ref = function () { + var prev = HEAP32[this.ptr >> 2]; + HEAP32[this.ptr >> 2] = prev - 1; + assert(prev > 0); + return prev === 1; + }; + this.set_adjusted_ptr = function (adjustedPtr) { + HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr; + }; + this.get_adjusted_ptr = function () { + return HEAPU32[(this.ptr + 16) >> 2]; + }; + this.get_exception_ptr = function () { + var isPointer = ___cxa_is_pointer_type(this.get_type()); + if (isPointer) { + return HEAPU32[this.excPtr >> 2]; + } + var adjusted = this.get_adjusted_ptr(); + if (adjusted !== 0) return adjusted; + return this.excPtr; + }; + } + var exceptionLast = 0; + var uncaughtExceptionCount = 0; + function ___cxa_throw(ptr, type, destructor) { + var info = new ExceptionInfo(ptr); + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw ( + ptr + + " - Exception catching is disabled, this exception cannot be caught. Compile with -sNO_DISABLE_EXCEPTION_CATCHING or -sEXCEPTION_CATCHING_ALLOWED=[..] to catch." + ); + } + function ___syscall_dup(fd) { + try { + var old = SYSCALLS.getStreamFromFD(fd); + return FS.createStream(old, 0).fd; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function setErrNo(value) { + HEAP32[___errno_location() >> 2] = value; + return value; + } + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.createStream(stream, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 5: { + var arg = SYSCALLS.get(); + var offset = 0; + HEAP16[(arg + offset) >> 1] = 2; + return 0; + } + case 6: + case 7: + return 0; + case 16: + case 8: + return -28; + case 9: + setErrNo(28); + return -1; + default: { + return -28; + } + } + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_fstat64(fd, buf) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: { + if (!stream.tty) return -59; + return 0; + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: { + if (!stream.tty) return -59; + return 0; + } + case 21519: { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + HEAP32[argp >> 2] = 0; + return 0; + } + case 21520: { + if (!stream.tty) return -59; + return -28; + } + case 21531: { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + case 21523: { + if (!stream.tty) return -59; + return 0; + } + case 21524: { + if (!stream.tty) return -59; + return 0; + } + default: + return -28; + } + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_lstat64(path, buf) { + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_newfstatat(dirfd, path, buf, flags) { + try { + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & ~6400; + assert(!flags, "unknown flags in __syscall_newfstatat: " + flags); + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? SYSCALLS.get() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_stat64(path, buf) { + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function __dlinit(main_dso_handle) {} + var dlopenMissingError = + "To use dlopen, you need enable dynamic linking, see https://github.com/emscripten-core/emscripten/wiki/Linking"; + function __dlopen_js(filename, flag) { + abort(dlopenMissingError); + } + function __dlsym_js(handle, symbol) { + abort(dlopenMissingError); + } + var char_0 = 48; + var char_9 = 57; + function makeLegalFunctionName(name) { + if (undefined === name) { + return "_unknown"; + } + name = name.replace(/[^a-zA-Z0-9_]/g, "$"); + var f = name.charCodeAt(0); + if (f >= char_0 && f <= char_9) { + return "_" + name; + } + return name; + } + function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + return function () { + "use strict"; + return body.apply(this, arguments); + }; + } + var emval_handle_array = [ + {}, + { value: undefined }, + { value: null }, + { value: true }, + { value: false }, + ]; + var emval_free_list = []; + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function (message) { + this.name = errorName; + this.message = message; + var stack = new Error(message).stack; + if (stack !== undefined) { + this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, ""); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function () { + if (this.message === undefined) { + return this.name; + } else { + return this.name + ": " + this.message; + } + }; + return errorClass; + } + var BindingError = undefined; + function throwBindingError(message) { + throw new BindingError(message); + } + function count_emval_handles() { + var count = 0; + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + ++count; + } + } + return count; + } + function get_first_emval() { + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + return emval_handle_array[i]; + } + } + return null; + } + function init_emval() { + Module["count_emval_handles"] = count_emval_handles; + Module["get_first_emval"] = get_first_emval; + } + var Emval = { + toValue: (handle) => { + if (!handle) { + throwBindingError("Cannot use deleted val. handle = " + handle); + } + return emval_handle_array[handle].value; + }, + toHandle: (value) => { + switch (value) { + case undefined: + return 1; + case null: + return 2; + case true: + return 3; + case false: + return 4; + default: { + var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length; + emval_handle_array[handle] = { refcount: 1, value: value }; + return handle; + } + } + }, + }; + var PureVirtualError = undefined; + function embind_init_charCodes() { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + } + var embind_charCodes = undefined; + function readLatin1String(ptr) { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + } + function getInheritedInstanceCount() { + return Object.keys(registeredInstances).length; + } + function getLiveInheritedInstances() { + var rv = []; + for (var k in registeredInstances) { + if (Object.hasOwn(registeredInstances, k)) { + rv.push(registeredInstances[k]); + } + } + return rv; + } + var deletionQueue = []; + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj["delete"](); + } + } + var delayFunction = undefined; + function setDelayFunction(fn) { + delayFunction = fn; + if (deletionQueue.length && delayFunction) { + delayFunction(flushPendingDeletes); + } + } + function init_embind() { + Module["getInheritedInstanceCount"] = getInheritedInstanceCount; + Module["getLiveInheritedInstances"] = getLiveInheritedInstances; + Module["flushPendingDeletes"] = flushPendingDeletes; + Module["setDelayFunction"] = setDelayFunction; + } + var registeredInstances = {}; + function getBasestPointer(class_, ptr) { + if (ptr === undefined) { + throwBindingError("ptr should not be undefined"); + } + while (class_.baseClass) { + ptr = class_.upcast(ptr); + class_ = class_.baseClass; + } + return ptr; + } + function registerInheritedInstance(class_, ptr, instance) { + ptr = getBasestPointer(class_, ptr); + if (Object.hasOwn(registeredInstances, ptr)) { + throwBindingError("Tried to register registered instance: " + ptr); + } else { + registeredInstances[ptr] = instance; + } + } + var registeredTypes = {}; + function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; + } + function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); + } + return impl; + } + function unregisterInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + if (Object.hasOwn(registeredInstances, ptr)) { + delete registeredInstances[ptr]; + } else { + throwBindingError("Tried to unregister unregistered instance: " + ptr); + } + } + function detachFinalizer(handle) {} + var finalizationRegistry = false; + function runDestructor($$) { + if ($$.smartPtr) { + $$.smartPtrType.rawDestructor($$.smartPtr); + } else { + $$.ptrType.registeredClass.rawDestructor($$.ptr); + } + } + function releaseClassHandle($$) { + $$.count.value -= 1; + var toDelete = 0 === $$.count.value; + if (toDelete) { + runDestructor($$); + } + } + function downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (undefined === desiredClass.baseClass) { + return null; + } + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); + } + var registeredPointers = {}; + function getInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + return registeredInstances[ptr]; + } + var InternalError = undefined; + function throwInternalError(message) { + throw new InternalError(message); + } + function makeClassHandle(prototype, record) { + if (!record.ptrType || !record.ptr) { + throwInternalError("makeClassHandle requires ptr and ptrType"); + } + var hasSmartPtrType = !!record.smartPtrType; + var hasSmartPtr = !!record.smartPtr; + if (hasSmartPtrType !== hasSmartPtr) { + throwInternalError("Both smartPtrType and smartPtr must be specified"); + } + record.count = { value: 1 }; + return attachFinalizer(Object.create(prototype, { $$: { value: record } })); + } + function RegisteredPointer_fromWireType(ptr) { + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance["clone"](); + } else { + var rv = registeredInstance["clone"](); + this.destructor(ptr); + return rv; + } + } + function makeDefaultHandle() { + if (this.isSmartPointer) { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this.pointeeType, + ptr: rawPointer, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this, + ptr: ptr, + }); + } + } + var actualType = this.registeredClass.getActualType(rawPointer); + var registeredPointerRecord = registeredPointers[actualType]; + if (!registeredPointerRecord) { + return makeDefaultHandle.call(this); + } + var toType; + if (this.isConst) { + toType = registeredPointerRecord.constPointerType; + } else { + toType = registeredPointerRecord.pointerType; + } + var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass); + if (dp === null) { + return makeDefaultHandle.call(this); + } + if (this.isSmartPointer) { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + }); + } + } + function attachFinalizer(handle) { + if ("undefined" === typeof FinalizationRegistry) { + attachFinalizer = (handle) => handle; + return handle; + } + finalizationRegistry = new FinalizationRegistry((info) => { + console.warn(info.leakWarning.stack.replace(/^Error: /, "")); + releaseClassHandle(info.$$); + }); + attachFinalizer = (handle) => { + var $$ = handle.$$; + var hasSmartPtr = !!$$.smartPtr; + if (hasSmartPtr) { + var info = { $$: $$ }; + var cls = $$.ptrType.registeredClass; + info.leakWarning = new Error( + "Embind found a leaked C++ instance " + + cls.name + + " <" + + ptrToString($$.ptr) + + ">.\n" + + "We'll free it automatically in this case, but this functionality is not reliable across various environments.\n" + + "Make sure to invoke .delete() manually once you're done with the instance instead.\n" + + "Originally allocated", + ); + if ("captureStackTrace" in Error) { + Error.captureStackTrace(info.leakWarning, RegisteredPointer_fromWireType); + } + finalizationRegistry.register(handle, info, handle); + } + return handle; + }; + detachFinalizer = (handle) => finalizationRegistry.unregister(handle); + return attachFinalizer(handle); + } + function __embind_create_inheriting_constructor(constructorName, wrapperType, properties) { + constructorName = readLatin1String(constructorName); + wrapperType = requireRegisteredType(wrapperType, "wrapper"); + properties = Emval.toValue(properties); + var arraySlice = [].slice; + var registeredClass = wrapperType.registeredClass; + var wrapperPrototype = registeredClass.instancePrototype; + var baseClass = registeredClass.baseClass; + var baseClassPrototype = baseClass.instancePrototype; + var baseConstructor = registeredClass.baseClass.constructor; + var ctor = createNamedFunction(constructorName, function () { + registeredClass.baseClass.pureVirtualFunctions.forEach( + function (name) { + if (this[name] === baseClassPrototype[name]) { + throw new PureVirtualError( + "Pure virtual function " + name + " must be implemented in JavaScript", + ); + } + }.bind(this), + ); + Object.defineProperty(this, "__parent", { value: wrapperPrototype }); + this["__construct"].apply(this, arraySlice.call(arguments)); + }); + wrapperPrototype["__construct"] = function __construct() { + if (this === wrapperPrototype) { + throwBindingError("Pass correct 'this' to __construct"); + } + var inner = baseConstructor["implement"].apply( + undefined, + [this].concat(arraySlice.call(arguments)), + ); + detachFinalizer(inner); + var $$ = inner.$$; + inner["notifyOnDestruction"](); + $$.preservePointerOnDelete = true; + Object.defineProperties(this, { $$: { value: $$ } }); + attachFinalizer(this); + registerInheritedInstance(registeredClass, $$.ptr, this); + }; + wrapperPrototype["__destruct"] = function __destruct() { + if (this === wrapperPrototype) { + throwBindingError("Pass correct 'this' to __destruct"); + } + detachFinalizer(this); + unregisterInheritedInstance(registeredClass, this.$$.ptr); + }; + ctor.prototype = Object.create(wrapperPrototype); + for (var p in properties) { + ctor.prototype[p] = properties[p]; + } + return Emval.toHandle(ctor); + } + var structRegistrations = {}; + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + } + function simpleReadValueFromPointer(pointer) { + return this["fromWireType"](HEAP32[pointer >> 2]); + } + var awaitingDependencies = {}; + var typeDependencies = {}; + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function (type) { + typeDependencies[type] = dependentTypes; + }); + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError("Mismatched type converter count"); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (Object.hasOwn(registeredTypes, dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!Object.hasOwn(awaitingDependencies, dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + } + function __embind_finalize_value_object(structType) { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords + .map((field) => field.getterReturnType) + .concat(fieldRecords.map((field) => field.setterArgumentType)); + whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes) => { + var fields = {}; + fieldRecords.forEach((field, i) => { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: (ptr) => { + return getterReturnType["fromWireType"](getter(getterContext, ptr)); + }, + write: (ptr, o) => { + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o)); + runDestructors(destructors); + }, + }; + }); + return [ + { + name: reg.name, + fromWireType: function (ptr) { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + toWireType: function (destructors, o) { + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError('Missing field: "' + fieldName + '"'); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + argPackAdvance: 8, + readValueFromPointer: simpleReadValueFromPointer, + destructorFunction: rawDestructor, + }, + ]; + }); + } + function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {} + function getShiftFromSize(size) { + switch (size) { + case 1: + return 0; + case 2: + return 1; + case 4: + return 2; + case 8: + return 3; + default: + throw new TypeError("Unknown type size: " + size); + } + } + function registerType(rawType, registeredInstance, options = {}) { + if (!("argPackAdvance" in registeredInstance)) { + throw new TypeError("registerType registeredInstance requires argPackAdvance"); + } + var name = registeredInstance.name; + if (!rawType) { + throwBindingError('type "' + name + '" must have a positive integer typeid pointer'); + } + if (Object.hasOwn(registeredTypes, rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError("Cannot register type '" + name + "' twice"); + } + } + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + if (Object.hasOwn(awaitingDependencies, rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach((cb) => cb()); + } + } + function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + fromWireType: function (wt) { + return !!wt; + }, + toWireType: function (destructors, o) { + return o ? trueValue : falseValue; + }, + argPackAdvance: 8, + readValueFromPointer: function (pointer) { + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name); + } + return this["fromWireType"](heap[pointer >> shift]); + }, + destructorFunction: null, + }); + } + function ClassHandle_isAliasOf(other) { + if (!(this instanceof ClassHandle)) { + return false; + } + if (!(other instanceof ClassHandle)) { + return false; + } + var leftClass = this.$$.ptrType.registeredClass; + var left = this.$$.ptr; + var rightClass = other.$$.ptrType.registeredClass; + var right = other.$$.ptr; + while (leftClass.baseClass) { + left = leftClass.upcast(left); + leftClass = leftClass.baseClass; + } + while (rightClass.baseClass) { + right = rightClass.upcast(right); + rightClass = rightClass.baseClass; + } + return leftClass === rightClass && left === right; + } + function shallowCopyInternalPointer(o) { + return { + count: o.count, + deleteScheduled: o.deleteScheduled, + preservePointerOnDelete: o.preservePointerOnDelete, + ptr: o.ptr, + ptrType: o.ptrType, + smartPtr: o.smartPtr, + smartPtrType: o.smartPtrType, + }; + } + function throwInstanceAlreadyDeleted(obj) { + function getInstanceTypeName(handle) { + return handle.$$.ptrType.registeredClass.name; + } + throwBindingError(getInstanceTypeName(obj) + " instance already deleted"); + } + function ClassHandle_clone() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.preservePointerOnDelete) { + this.$$.count.value += 1; + return this; + } else { + var clone = attachFinalizer( + Object.create(Object.getPrototypeOf(this), { + $$: { value: shallowCopyInternalPointer(this.$$) }, + }), + ); + clone.$$.count.value += 1; + clone.$$.deleteScheduled = false; + return clone; + } + } + function ClassHandle_delete() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion"); + } + detachFinalizer(this); + releaseClassHandle(this.$$); + if (!this.$$.preservePointerOnDelete) { + this.$$.smartPtr = undefined; + this.$$.ptr = undefined; + } + } + function ClassHandle_isDeleted() { + return !this.$$.ptr; + } + function ClassHandle_deleteLater() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion"); + } + deletionQueue.push(this); + if (deletionQueue.length === 1 && delayFunction) { + delayFunction(flushPendingDeletes); + } + this.$$.deleteScheduled = true; + return this; + } + function init_ClassHandle() { + ClassHandle.prototype["isAliasOf"] = ClassHandle_isAliasOf; + ClassHandle.prototype["clone"] = ClassHandle_clone; + ClassHandle.prototype["delete"] = ClassHandle_delete; + ClassHandle.prototype["isDeleted"] = ClassHandle_isDeleted; + ClassHandle.prototype["deleteLater"] = ClassHandle_deleteLater; + } + function ClassHandle() {} + function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + proto[methodName] = function () { + if (!Object.hasOwn(proto[methodName].overloadTable, arguments.length)) { + throwBindingError( + "Function '" + + humanName + + "' called with an invalid number of arguments (" + + arguments.length + + ") - expects one of (" + + proto[methodName].overloadTable + + ")!", + ); + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments); + }; + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + } + function exposePublicSymbol(name, value, numArguments) { + if (Object.hasOwn(Module, name)) { + if ( + undefined === numArguments || + (undefined !== Module[name].overloadTable && + undefined !== Module[name].overloadTable[numArguments]) + ) { + throwBindingError("Cannot register public name '" + name + "' twice"); + } + ensureOverloadTable(Module, name, name); + if (Object.hasOwn(Module, numArguments)) { + throwBindingError( + "Cannot register multiple overloads of a function with the same number of arguments (" + + numArguments + + ")!", + ); + } + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + } + function RegisteredClass( + name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast, + ) { + this.name = name; + this.constructor = constructor; + this.instancePrototype = instancePrototype; + this.rawDestructor = rawDestructor; + this.baseClass = baseClass; + this.getActualType = getActualType; + this.upcast = upcast; + this.downcast = downcast; + this.pureVirtualFunctions = []; + } + function upcastPointer(ptr, ptrClass, desiredClass) { + while (ptrClass !== desiredClass) { + if (!ptrClass.upcast) { + throwBindingError( + "Expected null or instance of " + + desiredClass.name + + ", got an instance of " + + ptrClass.name, + ); + } + ptr = ptrClass.upcast(ptr); + ptrClass = ptrClass.baseClass; + } + return ptr; + } + function constNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + return 0; + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + function genericPointerToWireType(destructors, handle) { + var ptr; + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + if (this.isSmartPointer) { + ptr = this.rawConstructor(); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + return ptr; + } else { + return 0; + } + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + if (!this.isConst && handle.$$.ptrType.isConst) { + throwBindingError( + "Cannot convert argument of type " + + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + + " to parameter type " + + this.name, + ); + } + var handleClass = handle.$$.ptrType.registeredClass; + ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + if (this.isSmartPointer) { + if (undefined === handle.$$.smartPtr) { + throwBindingError("Passing raw pointer to smart pointer is illegal"); + } + switch (this.sharingPolicy) { + case 0: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + throwBindingError( + "Cannot convert argument of type " + + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + + " to parameter type " + + this.name, + ); + } + break; + case 1: + ptr = handle.$$.smartPtr; + break; + case 2: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle["clone"](); + ptr = this.rawShare( + ptr, + Emval.toHandle(function () { + clonedHandle["delete"](); + }), + ); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + } + break; + default: + throwBindingError("Unsupporting sharing policy"); + } + } + return ptr; + } + function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + return 0; + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + if (handle.$$.ptrType.isConst) { + throwBindingError( + "Cannot convert argument of type " + + handle.$$.ptrType.name + + " to parameter type " + + this.name, + ); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + function RegisteredPointer_getPointee(ptr) { + if (this.rawGetPointee) { + ptr = this.rawGetPointee(ptr); + } + return ptr; + } + function RegisteredPointer_destructor(ptr) { + if (this.rawDestructor) { + this.rawDestructor(ptr); + } + } + function RegisteredPointer_deleteObject(handle) { + if (handle !== null) { + handle["delete"](); + } + } + function init_RegisteredPointer() { + RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; + RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; + RegisteredPointer.prototype["argPackAdvance"] = 8; + RegisteredPointer.prototype["readValueFromPointer"] = simpleReadValueFromPointer; + RegisteredPointer.prototype["deleteObject"] = RegisteredPointer_deleteObject; + RegisteredPointer.prototype["fromWireType"] = RegisteredPointer_fromWireType; + } + function RegisteredPointer( + name, + registeredClass, + isReference, + isConst, + isSmartPointer, + pointeeType, + sharingPolicy, + rawGetPointee, + rawConstructor, + rawShare, + rawDestructor, + ) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + this.isSmartPointer = isSmartPointer; + this.pointeeType = pointeeType; + this.sharingPolicy = sharingPolicy; + this.rawGetPointee = rawGetPointee; + this.rawConstructor = rawConstructor; + this.rawShare = rawShare; + this.rawDestructor = rawDestructor; + if (!isSmartPointer && registeredClass.baseClass === undefined) { + if (isConst) { + this["toWireType"] = constNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } else { + this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } + } else { + this["toWireType"] = genericPointerToWireType; + } + } + function replacePublicSymbol(name, value, numArguments) { + if (!Object.hasOwn(Module, name)) { + throwInternalError("Replacing nonexistant public symbol"); + } + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + Module[name].argCount = numArguments; + } + } + function dynCallLegacy(sig, ptr, args) { + assert( + "dynCall_" + sig in Module, + "bad function pointer type - dynCall function not found for sig '" + sig + "'", + ); + if (args && args.length) { + assert(args.length === sig.substring(1).replace(/j/g, "--").length); + } else { + assert(sig.length == 1); + } + var f = Module["dynCall_" + sig]; + return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); + } + var wasmTableMirror = []; + function getWasmTableEntry(funcPtr) { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + assert( + wasmTable.get(funcPtr) == func, + "JavaScript-side Wasm function table mirror is out of date!", + ); + return func; + } + function dynCall(sig, ptr, args) { + if (sig.includes("j")) { + return dynCallLegacy(sig, ptr, args); + } + assert(getWasmTableEntry(ptr), "missing table entry in dynCall: " + ptr); + var rtn = getWasmTableEntry(ptr).apply(null, args); + return rtn; + } + function getDynCaller(sig, ptr) { + assert( + sig.includes("j") || sig.includes("p"), + "getDynCaller should only be called with i64 sigs", + ); + var argCache = []; + return function () { + argCache.length = 0; + Object.assign(argCache, arguments); + return dynCall(sig, ptr, argCache); + }; + } + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + function makeDynCaller() { + if (signature.includes("j")) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + var fp = makeDynCaller(); + if (typeof fp != "function") { + throwBindingError( + "unknown function pointer with signature " + signature + ": " + rawFunction, + ); + } + return fp; + } + var UnboundTypeError = undefined; + function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([", "])); + } + function __embind_register_class( + rawType, + rawPointerType, + rawConstPointerType, + baseClassRawType, + getActualTypeSignature, + getActualType, + upcastSignature, + upcast, + downcastSignature, + downcast, + name, + destructorSignature, + rawDestructor, + ) { + name = readLatin1String(name); + getActualType = embind__requireFunction(getActualTypeSignature, getActualType); + if (upcast) { + upcast = embind__requireFunction(upcastSignature, upcast); + } + if (downcast) { + downcast = embind__requireFunction(downcastSignature, downcast); + } + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + var legalFunctionName = makeLegalFunctionName(name); + exposePublicSymbol(legalFunctionName, function () { + throwUnboundTypeError("Cannot construct " + name + " due to unbound types", [ + baseClassRawType, + ]); + }); + whenDependentTypesAreResolved( + [rawType, rawPointerType, rawConstPointerType], + baseClassRawType ? [baseClassRawType] : [], + function (base) { + base = base[0]; + var baseClass; + var basePrototype; + if (baseClassRawType) { + baseClass = base.registeredClass; + basePrototype = baseClass.instancePrototype; + } else { + basePrototype = ClassHandle.prototype; + } + var constructor = createNamedFunction(legalFunctionName, function () { + if (Object.getPrototypeOf(this) !== instancePrototype) { + throw new BindingError("Use 'new' to construct " + name); + } + if (undefined === registeredClass.constructor_body) { + throw new BindingError(name + " has no accessible constructor"); + } + var body = registeredClass.constructor_body[arguments.length]; + if (undefined === body) { + throw new BindingError( + "Tried to invoke ctor of " + + name + + " with invalid number of parameters (" + + arguments.length + + ") - expected (" + + Object.keys(registeredClass.constructor_body).toString() + + ") parameters instead!", + ); + } + return body.apply(this, arguments); + }); + var instancePrototype = Object.create(basePrototype, { + constructor: { value: constructor }, + }); + constructor.prototype = instancePrototype; + var registeredClass = new RegisteredClass( + name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast, + ); + var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false); + var pointerConverter = new RegisteredPointer( + name + "*", + registeredClass, + false, + false, + false, + ); + var constPointerConverter = new RegisteredPointer( + name + " const*", + registeredClass, + false, + true, + false, + ); + registeredPointers[rawType] = { + pointerType: pointerConverter, + constPointerType: constPointerConverter, + }; + replacePublicSymbol(legalFunctionName, constructor); + return [referenceConverter, pointerConverter, constPointerConverter]; + }, + ); + } + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) { + var argCount = argTypes.length; + if (argCount < 2) { + throwBindingError( + "argTypes array size mismatch! Must at least get return value and 'this' types!", + ); + } + var isClassMethodFunc = argTypes[1] !== null && classType !== null; + var needsDestructorStack = false; + for (var i = 1; i < argTypes.length; ++i) { + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + needsDestructorStack = true; + break; + } + } + var returns = argTypes[0].name !== "void"; + var expectedArgCount = argCount - 2; + var argsWired = new Array(expectedArgCount); + var invokerFuncArgs = []; + var destructors = []; + return function () { + if (arguments.length !== expectedArgCount) { + throwBindingError( + "function " + + humanName + + " called with " + + arguments.length + + " arguments, expected " + + expectedArgCount + + " args!", + ); + } + destructors.length = 0; + var thisWired; + invokerFuncArgs.length = isClassMethodFunc ? 2 : 1; + invokerFuncArgs[0] = cppTargetFunc; + if (isClassMethodFunc) { + thisWired = argTypes[1]["toWireType"](destructors, this); + invokerFuncArgs[1] = thisWired; + } + for (var i = 0; i < expectedArgCount; ++i) { + argsWired[i] = argTypes[i + 2]["toWireType"](destructors, arguments[i]); + invokerFuncArgs.push(argsWired[i]); + } + var rv = cppInvokerFunc.apply(null, invokerFuncArgs); + function onDone(rv) { + if (needsDestructorStack) { + runDestructors(destructors); + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; i++) { + var param = i === 1 ? thisWired : argsWired[i - 2]; + if (argTypes[i].destructorFunction !== null) { + argTypes[i].destructorFunction(param); + } + } + } + if (returns) { + return argTypes[0]["fromWireType"](rv); + } + } + return onDone(rv); + }; + } + function heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAPU32[(firstElement + i * 4) >> 2]); + } + return array; + } + function __embind_register_class_class_function( + rawClassType, + methodName, + argCount, + rawArgTypesAddr, + invokerSignature, + rawInvoker, + fn, + ) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + methodName; + function unboundTypesHandler() { + throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes); + } + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + var proto = classType.registeredClass.constructor; + if (undefined === proto[methodName]) { + unboundTypesHandler.argCount = argCount - 1; + proto[methodName] = unboundTypesHandler; + } else { + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler; + } + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1)); + var func = craftInvokerFunction(humanName, invokerArgsArray, null, rawInvoker, fn); + if (undefined === proto[methodName].overloadTable) { + func.argCount = argCount - 1; + proto[methodName] = func; + } else { + proto[methodName].overloadTable[argCount - 1] = func; + } + return []; + }); + return []; + }); + } + function __embind_register_class_constructor( + rawClassType, + argCount, + rawArgTypesAddr, + invokerSignature, + invoker, + rawConstructor, + ) { + assert(argCount > 0); + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = "constructor " + classType.name; + if (undefined === classType.registeredClass.constructor_body) { + classType.registeredClass.constructor_body = []; + } + if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) { + throw new BindingError( + "Cannot register multiple constructors with identical number of parameters (" + + (argCount - 1) + + ") for class '" + + classType.name + + "'! Overload resolution is currently only performed using the parameter count, not actual type info!", + ); + } + classType.registeredClass.constructor_body[argCount - 1] = () => { + throwUnboundTypeError( + "Cannot construct " + classType.name + " due to unbound types", + rawArgTypes, + ); + }; + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + argTypes.splice(1, 0, null); + classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction( + humanName, + argTypes, + null, + invoker, + rawConstructor, + ); + return []; + }); + return []; + }); + } + function __embind_register_class_function( + rawClassType, + methodName, + argCount, + rawArgTypesAddr, + invokerSignature, + rawInvoker, + context, + isPureVirtual, + ) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + methodName; + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName); + } + function unboundTypesHandler() { + throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes); + } + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if ( + undefined === method || + (undefined === method.overloadTable && + method.className !== classType.name && + method.argCount === argCount - 2) + ) { + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler; + } else { + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler; + } + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + var memberFunction = craftInvokerFunction( + humanName, + argTypes, + classType, + rawInvoker, + context, + ); + if (undefined === proto[methodName].overloadTable) { + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction; + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction; + } + return []; + }); + return []; + }); + } + function validateThis(this_, classType, humanName) { + if (!(this_ instanceof Object)) { + throwBindingError(humanName + ' with invalid "this": ' + this_); + } + if (!(this_ instanceof classType.registeredClass.constructor)) { + throwBindingError( + humanName + ' incompatible with "this" of type ' + this_.constructor.name, + ); + } + if (!this_.$$.ptr) { + throwBindingError( + "cannot call emscripten binding method " + humanName + " on deleted object", + ); + } + return upcastPointer( + this_.$$.ptr, + this_.$$.ptrType.registeredClass, + classType.registeredClass, + ); + } + function __embind_register_class_property( + classType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext, + ) { + fieldName = readLatin1String(fieldName); + getter = embind__requireFunction(getterSignature, getter); + whenDependentTypesAreResolved([], [classType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + fieldName; + var desc = { + get: function () { + throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [ + getterReturnType, + setterArgumentType, + ]); + }, + enumerable: true, + configurable: true, + }; + if (setter) { + desc.set = () => { + throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [ + getterReturnType, + setterArgumentType, + ]); + }; + } else { + desc.set = (v) => { + throwBindingError(humanName + " is a read-only property"); + }; + } + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + whenDependentTypesAreResolved( + [], + setter ? [getterReturnType, setterArgumentType] : [getterReturnType], + function (types) { + var getterReturnType = types[0]; + var desc = { + get: function () { + var ptr = validateThis(this, classType, humanName + " getter"); + return getterReturnType["fromWireType"](getter(getterContext, ptr)); + }, + enumerable: true, + }; + if (setter) { + setter = embind__requireFunction(setterSignature, setter); + var setterArgumentType = types[1]; + desc.set = function (v) { + var ptr = validateThis(this, classType, humanName + " setter"); + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, v)); + runDestructors(destructors); + }; + } + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + return []; + }, + ); + return []; + }); + } + function __emval_decref(handle) { + if (handle > 4 && 0 === --emval_handle_array[handle].refcount) { + emval_handle_array[handle] = undefined; + emval_free_list.push(handle); + } + } + function __embind_register_emval(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + name: name, + fromWireType: function (handle) { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + toWireType: function (destructors, value) { + return Emval.toHandle(value); + }, + argPackAdvance: 8, + readValueFromPointer: simpleReadValueFromPointer, + destructorFunction: null, + }); + } + function embindRepr(v) { + if (v === null) { + return "null"; + } + var t = typeof v; + if (t === "object" || t === "array" || t === "function") { + return v.toString(); + } else { + return "" + v; + } + } + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: + return function (pointer) { + return this["fromWireType"](HEAPF32[pointer >> 2]); + }; + case 3: + return function (pointer) { + return this["fromWireType"](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name); + } + } + function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + fromWireType: function (value) { + return value; + }, + toWireType: function (destructors, value) { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError('Cannot convert "' + embindRepr(value) + '" to ' + this.name); + } + return value; + }, + argPackAdvance: 8, + readValueFromPointer: floatReadValueFromPointer(name, shift), + destructorFunction: null, + }); + } + function __embind_register_function( + name, + argCount, + rawArgTypesAddr, + signature, + rawInvoker, + fn, + ) { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + rawInvoker = embind__requireFunction(signature, rawInvoker); + exposePublicSymbol( + name, + function () { + throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes); + }, + argCount - 1, + ); + whenDependentTypesAreResolved([], argTypes, function (argTypes) { + var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1)); + replacePublicSymbol( + name, + craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), + argCount - 1, + ); + return []; + }); + } + function integerReadValueFromPointer(name, shift, signed) { + switch (shift) { + case 0: + return signed + ? function readS8FromPointer(pointer) { + return HEAP8[pointer]; + } + : function readU8FromPointer(pointer) { + return HEAPU8[pointer]; + }; + case 1: + return signed + ? function readS16FromPointer(pointer) { + return HEAP16[pointer >> 1]; + } + : function readU16FromPointer(pointer) { + return HEAPU16[pointer >> 1]; + }; + case 2: + return signed + ? function readS32FromPointer(pointer) { + return HEAP32[pointer >> 2]; + } + : function readU32FromPointer(pointer) { + return HEAPU32[pointer >> 2]; + }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + if (maxRange === -1) { + maxRange = 4294967295; + } + var shift = getShiftFromSize(size); + var fromWireType = (value) => value; + if (minRange === 0) { + var bitshift = 32 - 8 * size; + fromWireType = (value) => (value << bitshift) >>> bitshift; + } + var isUnsignedType = name.includes("unsigned"); + var checkAssertions = (value, toTypeName) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError('Cannot convert "' + embindRepr(value) + '" to ' + toTypeName); + } + if (value < minRange || value > maxRange) { + throw new TypeError( + 'Passing a number "' + + embindRepr(value) + + '" from JS side to C/C++ side to an argument of type "' + + name + + '", which is outside the valid range [' + + minRange + + ", " + + maxRange + + "]!", + ); + } + }; + var toWireType; + if (isUnsignedType) { + toWireType = function (destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + }; + } else { + toWireType = function (destructors, value) { + checkAssertions(value, this.name); + return value; + }; + } + registerType(primitiveType, { + name: name, + fromWireType: fromWireType, + toWireType: toWireType, + argPackAdvance: 8, + readValueFromPointer: integerReadValueFromPointer(name, shift, minRange !== 0), + destructorFunction: null, + }); + } + function __embind_register_memory_view(rawType, dataTypeIndex, name) { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + var TA = typeMapping[dataTypeIndex]; + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; + var data = heap[handle + 1]; + return new TA(buffer, data, size); + } + name = readLatin1String(name); + registerType( + rawType, + { + name: name, + fromWireType: decodeMemoryView, + argPackAdvance: 8, + readValueFromPointer: decodeMemoryView, + }, + { ignoreDuplicateRegistrations: true }, + ); + } + function __embind_register_std_string(rawType, name) { + name = readLatin1String(name); + var stdStringIsUTF8 = name === "std::string"; + registerType(rawType, { + name: name, + fromWireType: function (value) { + var length = HEAPU32[value >> 2]; + var payload = value + 4; + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = payload; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = payload + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[payload + i]); + } + str = a.join(""); + } + _free(value); + return str; + }, + toWireType: function (destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + var length; + var valueIsOfTypeString = typeof value == "string"; + if ( + !( + valueIsOfTypeString || + value instanceof Uint8Array || + value instanceof Uint8ClampedArray || + value instanceof Int8Array + ) + ) { + throwBindingError("Cannot pass non-string to std::string"); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + var base = _malloc(4 + length + 1); + var ptr = base + 4; + HEAPU32[base >> 2] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError("String has UTF-16 code units that do not fit in 8 bits"); + } + HEAPU8[ptr + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + i] = value[i]; + } + } + } + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + argPackAdvance: 8, + readValueFromPointer: simpleReadValueFromPointer, + destructorFunction: function (ptr) { + _free(ptr); + }, + }); + } + var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined; + function UTF16ToString(ptr, maxBytesToRead) { + assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!"); + var endPtr = ptr; + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + if (endPtr - ptr > 32 && UTF16Decoder) + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + var str = ""; + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(ptr + i * 2) >> 1]; + if (codeUnit == 0) break; + str += String.fromCharCode(codeUnit); + } + return str; + } + function stringToUTF16(str, outPtr, maxBytesToWrite) { + assert(outPtr % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!"); + assert( + typeof maxBytesToWrite == "number", + "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!", + ); + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; + var startPtr = outPtr; + var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + var codeUnit = str.charCodeAt(i); + HEAP16[outPtr >> 1] = codeUnit; + outPtr += 2; + } + HEAP16[outPtr >> 1] = 0; + return outPtr - startPtr; + } + function lengthBytesUTF16(str) { + return str.length * 2; + } + function UTF32ToString(ptr, maxBytesToRead) { + assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!"); + var i = 0; + var str = ""; + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(ptr + i * 4) >> 2]; + if (utf32 == 0) break; + ++i; + if (utf32 >= 65536) { + var ch = utf32 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; + } + function stringToUTF32(str, outPtr, maxBytesToWrite) { + assert(outPtr % 4 == 0, "Pointer passed to stringToUTF32 must be aligned to four bytes!"); + assert( + typeof maxBytesToWrite == "number", + "stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!", + ); + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = (65536 + ((codeUnit & 1023) << 10)) | (trailSurrogate & 1023); + } + HEAP32[outPtr >> 2] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + HEAP32[outPtr >> 2] = 0; + return outPtr - startPtr; + } + function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) ++i; + len += 4; + } + return len; + } + function __embind_register_std_wstring(rawType, charSize, name) { + name = readLatin1String(name); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = () => HEAPU16; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = () => HEAPU32; + shift = 2; + } + registerType(rawType, { + name: name, + fromWireType: function (value) { + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || HEAP[currentBytePtr >> shift] == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + _free(value); + return str; + }, + toWireType: function (destructors, value) { + if (!(typeof value == "string")) { + throwBindingError("Cannot pass non-string to C++ string type " + name); + } + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + encodeString(value, ptr + 4, length + charSize); + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + argPackAdvance: 8, + readValueFromPointer: simpleReadValueFromPointer, + destructorFunction: function (ptr) { + _free(ptr); + }, + }); + } + function __embind_register_value_object( + rawType, + name, + constructorSignature, + rawConstructor, + destructorSignature, + rawDestructor, + ) { + structRegistrations[rawType] = { + name: readLatin1String(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + fields: [], + }; + } + function __embind_register_value_object_field( + structType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext, + ) { + structRegistrations[structType].fields.push({ + fieldName: readLatin1String(fieldName), + getterReturnType: getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext: getterContext, + setterArgumentType: setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext: setterContext, + }); + } + function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, + name: name, + argPackAdvance: 0, + fromWireType: function () { + return undefined; + }, + toWireType: function (destructors, o) { + return undefined; + }, + }); + } + var nowIsMonotonic = true; + function __emscripten_get_now_is_monotonic() { + return nowIsMonotonic; + } + function __emval_as(handle, returnType, destructorsRef) { + handle = Emval.toValue(handle); + returnType = requireRegisteredType(returnType, "emval::as"); + var destructors = []; + var rd = Emval.toHandle(destructors); + HEAPU32[destructorsRef >> 2] = rd; + return returnType["toWireType"](destructors, handle); + } + var emval_symbols = {}; + function getStringOrSymbol(address) { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return readLatin1String(address); + } + return symbol; + } + var emval_methodCallers = []; + function __emval_call_void_method(caller, handle, methodName, args) { + caller = emval_methodCallers[caller]; + handle = Emval.toValue(handle); + methodName = getStringOrSymbol(methodName); + caller(handle, methodName, null, args); + } + function emval_get_global() { + if (typeof globalThis == "object") { + return globalThis; + } + function testGlobal(obj) { + obj["$$$embind_global$$$"] = obj; + var success = typeof $$$embind_global$$$ == "object" && obj["$$$embind_global$$$"] == obj; + if (!success) { + delete obj["$$$embind_global$$$"]; + } + return success; + } + if (typeof $$$embind_global$$$ == "object") { + return $$$embind_global$$$; + } + if (typeof global == "object" && testGlobal(global)) { + $$$embind_global$$$ = global; + } else if (typeof self == "object" && testGlobal(self)) { + $$$embind_global$$$ = self; + } + if (typeof $$$embind_global$$$ == "object") { + return $$$embind_global$$$; + } + throw Error("unable to get global object."); + } + function __emval_get_global(name) { + if (name === 0) { + return Emval.toHandle(emval_get_global()); + } else { + name = getStringOrSymbol(name); + return Emval.toHandle(emval_get_global()[name]); + } + } + function emval_addMethodCaller(caller) { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; + } + function emval_lookupTypes(argCount, argTypes) { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(HEAPU32[(argTypes + i * POINTER_SIZE) >> 2], "parameter " + i); + } + return a; + } + var emval_registeredMethods = []; + function __emval_get_method_caller(argCount, argTypes) { + var types = emval_lookupTypes(argCount, argTypes); + var retType = types[0]; + var signatureName = + retType.name + + "_$" + + types + .slice(1) + .map(function (t) { + return t.name; + }) + .join("_") + + "$"; + var returnId = emval_registeredMethods[signatureName]; + if (returnId !== undefined) { + return returnId; + } + var argN = new Array(argCount - 1); + var invokerFunction = (handle, name, destructors, args) => { + var offset = 0; + for (var i = 0; i < argCount - 1; ++i) { + argN[i] = types[i + 1]["readValueFromPointer"](args + offset); + offset += types[i + 1]["argPackAdvance"]; + } + var rv = handle[name].apply(handle, argN); + for (var i = 0; i < argCount - 1; ++i) { + if (types[i + 1].deleteObject) { + types[i + 1].deleteObject(argN[i]); + } + } + if (!retType.isVoid) { + return retType["toWireType"](destructors, rv); + } + }; + returnId = emval_addMethodCaller(invokerFunction); + emval_registeredMethods[signatureName] = returnId; + return returnId; + } + function __emval_get_property(handle, key) { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + return Emval.toHandle(handle[key]); + } + function __emval_incref(handle) { + if (handle > 4) { + emval_handle_array[handle].refcount += 1; + } + } + function __emval_instanceof(object, constructor) { + object = Emval.toValue(object); + constructor = Emval.toValue(constructor); + return object instanceof constructor; + } + function __emval_new_cstring(v) { + return Emval.toHandle(getStringOrSymbol(v)); + } + function __emval_run_destructors(handle) { + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); + } + function __emval_set_property(handle, key, value) { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + value = Emval.toValue(value); + handle[key] = value; + } + function __emval_take_value(type, arg) { + type = requireRegisteredType(type, "_emval_take_value"); + var v = type["readValueFromPointer"](arg); + return Emval.toHandle(v); + } + function __emval_typeof(handle) { + handle = Emval.toValue(handle); + return Emval.toHandle(typeof handle); + } + function readI53FromI64(ptr) { + return HEAPU32[ptr >> 2] + HEAP32[(ptr + 4) >> 2] * 4294967296; + } + function __gmtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time) * 1e3); + HEAP32[tmPtr >> 2] = date.getUTCSeconds(); + HEAP32[(tmPtr + 4) >> 2] = date.getUTCMinutes(); + HEAP32[(tmPtr + 8) >> 2] = date.getUTCHours(); + HEAP32[(tmPtr + 12) >> 2] = date.getUTCDate(); + HEAP32[(tmPtr + 16) >> 2] = date.getUTCMonth(); + HEAP32[(tmPtr + 20) >> 2] = date.getUTCFullYear() - 1900; + HEAP32[(tmPtr + 24) >> 2] = date.getUTCDay(); + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = ((date.getTime() - start) / (1e3 * 60 * 60 * 24)) | 0; + HEAP32[(tmPtr + 28) >> 2] = yday; + } + function __isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + } + var __MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]; + var __MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; + function __yday_from_date(date) { + var isLeapYear = __isLeapYear(date.getFullYear()); + var monthDaysCumulative = isLeapYear + ? __MONTH_DAYS_LEAP_CUMULATIVE + : __MONTH_DAYS_REGULAR_CUMULATIVE; + var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; + return yday; + } + function __localtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time) * 1e3); + HEAP32[tmPtr >> 2] = date.getSeconds(); + HEAP32[(tmPtr + 4) >> 2] = date.getMinutes(); + HEAP32[(tmPtr + 8) >> 2] = date.getHours(); + HEAP32[(tmPtr + 12) >> 2] = date.getDate(); + HEAP32[(tmPtr + 16) >> 2] = date.getMonth(); + HEAP32[(tmPtr + 20) >> 2] = date.getFullYear() - 1900; + HEAP32[(tmPtr + 24) >> 2] = date.getDay(); + var yday = __yday_from_date(date) | 0; + HEAP32[(tmPtr + 28) >> 2] = yday; + HEAP32[(tmPtr + 36) >> 2] = -(date.getTimezoneOffset() * 60); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = + (summerOffset != winterOffset && + date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0; + HEAP32[(tmPtr + 32) >> 2] = dst; + } + function __mktime_js(tmPtr) { + var date = new Date( + HEAP32[(tmPtr + 20) >> 2] + 1900, + HEAP32[(tmPtr + 16) >> 2], + HEAP32[(tmPtr + 12) >> 2], + HEAP32[(tmPtr + 8) >> 2], + HEAP32[(tmPtr + 4) >> 2], + HEAP32[tmPtr >> 2], + 0, + ); + var dst = HEAP32[(tmPtr + 32) >> 2]; + var guessedOffset = date.getTimezoneOffset(); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dstOffset = Math.min(winterOffset, summerOffset); + if (dst < 0) { + HEAP32[(tmPtr + 32) >> 2] = Number( + summerOffset != winterOffset && dstOffset == guessedOffset, + ); + } else if (dst > 0 != (dstOffset == guessedOffset)) { + var nonDstOffset = Math.max(winterOffset, summerOffset); + var trueOffset = dst > 0 ? dstOffset : nonDstOffset; + date.setTime(date.getTime() + (trueOffset - guessedOffset) * 6e4); + } + HEAP32[(tmPtr + 24) >> 2] = date.getDay(); + var yday = __yday_from_date(date) | 0; + HEAP32[(tmPtr + 28) >> 2] = yday; + HEAP32[tmPtr >> 2] = date.getSeconds(); + HEAP32[(tmPtr + 4) >> 2] = date.getMinutes(); + HEAP32[(tmPtr + 8) >> 2] = date.getHours(); + HEAP32[(tmPtr + 12) >> 2] = date.getDate(); + HEAP32[(tmPtr + 16) >> 2] = date.getMonth(); + HEAP32[(tmPtr + 20) >> 2] = date.getYear(); + return (date.getTime() / 1e3) | 0; + } + function __mmap_js(len, prot, flags, fd, off, allocated, addr) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var res = FS.mmap(stream, len, off, prot, flags); + var ptr = res.ptr; + HEAP32[allocated >> 2] = res.allocated; + HEAPU32[addr >> 2] = ptr; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function __munmap_js(addr, len, prot, flags, fd, offset) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + if (prot & 2) { + SYSCALLS.doMsync(addr, stream, len, flags, offset); + } + FS.munmap(stream); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; + } + function __tzset_js(timezone, daylight, tzname) { + var currentYear = new Date().getFullYear(); + var winter = new Date(currentYear, 0, 1); + var summer = new Date(currentYear, 6, 1); + var winterOffset = winter.getTimezoneOffset(); + var summerOffset = summer.getTimezoneOffset(); + var stdTimezoneOffset = Math.max(winterOffset, summerOffset); + HEAPU32[timezone >> 2] = stdTimezoneOffset * 60; + HEAP32[daylight >> 2] = Number(winterOffset != summerOffset); + function extractZone(date) { + var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/); + return match ? match[1] : "GMT"; + } + var winterName = extractZone(winter); + var summerName = extractZone(summer); + var winterNamePtr = allocateUTF8(winterName); + var summerNamePtr = allocateUTF8(summerName); + if (summerOffset < winterOffset) { + HEAPU32[tzname >> 2] = winterNamePtr; + HEAPU32[(tzname + 4) >> 2] = summerNamePtr; + } else { + HEAPU32[tzname >> 2] = summerNamePtr; + HEAPU32[(tzname + 4) >> 2] = winterNamePtr; + } + } + function _abort() { + abort("native code called abort()"); + } + var readEmAsmArgsArray = []; + function readEmAsmArgs(sigPtr, buf) { + assert(Array.isArray(readEmAsmArgsArray)); + assert(buf % 16 == 0); + readEmAsmArgsArray.length = 0; + var ch; + buf >>= 2; + while ((ch = HEAPU8[sigPtr++])) { + var chr = String.fromCharCode(ch); + var validChars = ["d", "f", "i"]; + assert( + validChars.includes(chr), + "Invalid character " + + ch + + '("' + + chr + + '") in readEmAsmArgs! Use only [' + + validChars + + '], and do not specify "v" for void return argument.', + ); + buf += (ch != 105) & buf; + readEmAsmArgsArray.push(ch == 105 ? HEAP32[buf] : HEAPF64[buf++ >> 1]); + ++buf; + } + return readEmAsmArgsArray; + } + function runEmAsmFunction(code, sigPtr, argbuf) { + var args = readEmAsmArgs(sigPtr, argbuf); + if (!Object.hasOwn(ASM_CONSTS, code)) abort("No EM_ASM constant found at address " + code); + return ASM_CONSTS[code].apply(null, args); + } + function _emscripten_asm_const_int(code, sigPtr, argbuf) { + return runEmAsmFunction(code, sigPtr, argbuf); + } + function _emscripten_date_now() { + return Date.now(); + } + function getHeapMax() { + return 2147483648; + } + function _emscripten_get_heap_max() { + return getHeapMax(); + } + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + function _emscripten_pc_get_function(pc) { + abort("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER"); + } + function emscripten_realloc_buffer(size) { + try { + wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16); + updateGlobalBufferAndViews(wasmMemory.buffer); + return 1; + } catch (e) { + err( + "emscripten_realloc_buffer: Attempted to grow heap from " + + buffer.byteLength + + " bytes to " + + size + + " bytes, but got error: " + + e, + ); + } + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + assert(requestedSize > oldSize); + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + err( + "Cannot enlarge memory, asked to go up to " + + requestedSize + + " bytes, but the limit is " + + maxHeapSize + + " bytes!", + ); + return false; + } + let alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple); + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min( + maxHeapSize, + alignUp(Math.max(requestedSize, overGrownHeapSize), 65536), + ); + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + return true; + } + } + err( + "Failed to grow the heap from " + + oldSize + + " bytes to " + + newSize + + " bytes, not enough memory!", + ); + return false; + } + function convertFrameToPC(frame) { + abort( + "Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER", + ); + return 0; + } + var UNWIND_CACHE = {}; + function saveInUnwindCache(callstack) { + callstack.forEach((frame) => { + var pc = convertFrameToPC(frame); + if (pc) { + UNWIND_CACHE[pc] = frame; + } + }); + } + function jsStackTrace() { + var error = new Error(); + if (!error.stack) { + try { + throw new Error(); + } catch (e) { + error = e; + } + if (!error.stack) { + return "(no stack trace available)"; + } + } + return error.stack.toString(); + } + function _emscripten_stack_snapshot() { + var callstack = jsStackTrace().split("\n"); + if (callstack[0] == "Error") { + callstack.shift(); + } + saveInUnwindCache(callstack); + UNWIND_CACHE.last_addr = convertFrameToPC(callstack[3]); + UNWIND_CACHE.last_stack = callstack; + return UNWIND_CACHE.last_addr; + } + function _emscripten_stack_unwind_buffer(addr, buffer, count) { + var stack; + if (UNWIND_CACHE.last_addr == addr) { + stack = UNWIND_CACHE.last_stack; + } else { + stack = jsStackTrace().split("\n"); + if (stack[0] == "Error") { + stack.shift(); + } + saveInUnwindCache(stack); + } + var offset = 3; + while (stack[offset] && convertFrameToPC(stack[offset]) != addr) { + ++offset; + } + for (var i = 0; i < count && stack[i + offset]; ++i) { + HEAP32[(buffer + i * 4) >> 2] = convertFrameToPC(stack[i + offset]); + } + return i; + } + function __webgl_enable_ANGLE_instanced_arrays(ctx) { + var ext = ctx.getExtension("ANGLE_instanced_arrays"); + if (ext) { + ctx["vertexAttribDivisor"] = function (index, divisor) { + ext["vertexAttribDivisorANGLE"](index, divisor); + }; + ctx["drawArraysInstanced"] = function (mode, first, count, primcount) { + ext["drawArraysInstancedANGLE"](mode, first, count, primcount); + }; + ctx["drawElementsInstanced"] = function (mode, count, type, indices, primcount) { + ext["drawElementsInstancedANGLE"](mode, count, type, indices, primcount); + }; + return 1; + } + } + function __webgl_enable_OES_vertex_array_object(ctx) { + var ext = ctx.getExtension("OES_vertex_array_object"); + if (ext) { + ctx["createVertexArray"] = function () { + return ext["createVertexArrayOES"](); + }; + ctx["deleteVertexArray"] = function (vao) { + ext["deleteVertexArrayOES"](vao); + }; + ctx["bindVertexArray"] = function (vao) { + ext["bindVertexArrayOES"](vao); + }; + ctx["isVertexArray"] = function (vao) { + return ext["isVertexArrayOES"](vao); + }; + return 1; + } + } + function __webgl_enable_WEBGL_draw_buffers(ctx) { + var ext = ctx.getExtension("WEBGL_draw_buffers"); + if (ext) { + ctx["drawBuffers"] = function (n, bufs) { + ext["drawBuffersWEBGL"](n, bufs); + }; + return 1; + } + } + function __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(ctx) { + return !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance")); + } + function __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(ctx) { + return !!(ctx.mdibvbi = ctx.getExtension( + "WEBGL_multi_draw_instanced_base_vertex_base_instance", + )); + } + function __webgl_enable_WEBGL_multi_draw(ctx) { + return !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw")); + } + var GL = { + counter: 1, + buffers: [], + mappedBuffers: {}, + programs: [], + framebuffers: [], + renderbuffers: [], + textures: [], + shaders: [], + vaos: [], + contexts: [], + offscreenCanvases: {}, + queries: [], + samplers: [], + transformFeedbacks: [], + syncs: [], + byteSizeByTypeRoot: 5120, + byteSizeByType: [1, 1, 2, 2, 4, 4, 4, 2, 3, 4, 8], + stringCache: {}, + stringiCache: {}, + unpackAlignment: 4, + recordError: function recordError(errorCode) { + if (!GL.lastError) { + GL.lastError = errorCode; + } + }, + getNewId: function (table) { + var ret = GL.counter++; + for (var i = table.length; i < ret; i++) { + table[i] = null; + } + return ret; + }, + MAX_TEMP_BUFFER_SIZE: 2097152, + numTempVertexBuffersPerSize: 64, + log2ceilLookup: function (i) { + return 32 - Math.clz32(i === 0 ? 0 : i - 1); + }, + generateTempBuffers: function (quads, context) { + var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE); + context.tempVertexBufferCounters1 = []; + context.tempVertexBufferCounters2 = []; + context.tempVertexBufferCounters1.length = context.tempVertexBufferCounters2.length = + largestIndex + 1; + context.tempVertexBuffers1 = []; + context.tempVertexBuffers2 = []; + context.tempVertexBuffers1.length = context.tempVertexBuffers2.length = largestIndex + 1; + context.tempIndexBuffers = []; + context.tempIndexBuffers.length = largestIndex + 1; + for (var i = 0; i <= largestIndex; ++i) { + context.tempIndexBuffers[i] = null; + context.tempVertexBufferCounters1[i] = context.tempVertexBufferCounters2[i] = 0; + var ringbufferLength = GL.numTempVertexBuffersPerSize; + context.tempVertexBuffers1[i] = []; + context.tempVertexBuffers2[i] = []; + var ringbuffer1 = context.tempVertexBuffers1[i]; + var ringbuffer2 = context.tempVertexBuffers2[i]; + ringbuffer1.length = ringbuffer2.length = ringbufferLength; + for (var j = 0; j < ringbufferLength; ++j) { + ringbuffer1[j] = ringbuffer2[j] = null; + } + } + if (quads) { + context.tempQuadIndexBuffer = GLctx.createBuffer(); + context.GLctx.bindBuffer(34963, context.tempQuadIndexBuffer); + var numIndexes = GL.MAX_TEMP_BUFFER_SIZE >> 1; + var quadIndexes = new Uint16Array(numIndexes); + var i = 0, + v = 0; + while (1) { + quadIndexes[i++] = v; + if (i >= numIndexes) break; + quadIndexes[i++] = v + 1; + if (i >= numIndexes) break; + quadIndexes[i++] = v + 2; + if (i >= numIndexes) break; + quadIndexes[i++] = v; + if (i >= numIndexes) break; + quadIndexes[i++] = v + 2; + if (i >= numIndexes) break; + quadIndexes[i++] = v + 3; + if (i >= numIndexes) break; + v += 4; + } + context.GLctx.bufferData(34963, quadIndexes, 35044); + context.GLctx.bindBuffer(34963, null); + } + }, + getTempVertexBuffer: function getTempVertexBuffer(sizeBytes) { + var idx = GL.log2ceilLookup(sizeBytes); + var ringbuffer = GL.currentContext.tempVertexBuffers1[idx]; + var nextFreeBufferIndex = GL.currentContext.tempVertexBufferCounters1[idx]; + GL.currentContext.tempVertexBufferCounters1[idx] = + (GL.currentContext.tempVertexBufferCounters1[idx] + 1) & + (GL.numTempVertexBuffersPerSize - 1); + var vbo = ringbuffer[nextFreeBufferIndex]; + if (vbo) { + return vbo; + } + var prevVBO = GLctx.getParameter(34964); + ringbuffer[nextFreeBufferIndex] = GLctx.createBuffer(); + GLctx.bindBuffer(34962, ringbuffer[nextFreeBufferIndex]); + GLctx.bufferData(34962, 1 << idx, 35048); + GLctx.bindBuffer(34962, prevVBO); + return ringbuffer[nextFreeBufferIndex]; + }, + getTempIndexBuffer: function getTempIndexBuffer(sizeBytes) { + var idx = GL.log2ceilLookup(sizeBytes); + var ibo = GL.currentContext.tempIndexBuffers[idx]; + if (ibo) { + return ibo; + } + var prevIBO = GLctx.getParameter(34965); + GL.currentContext.tempIndexBuffers[idx] = GLctx.createBuffer(); + GLctx.bindBuffer(34963, GL.currentContext.tempIndexBuffers[idx]); + GLctx.bufferData(34963, 1 << idx, 35048); + GLctx.bindBuffer(34963, prevIBO); + return GL.currentContext.tempIndexBuffers[idx]; + }, + newRenderingFrameStarted: function newRenderingFrameStarted() { + if (!GL.currentContext) { + return; + } + var vb = GL.currentContext.tempVertexBuffers1; + GL.currentContext.tempVertexBuffers1 = GL.currentContext.tempVertexBuffers2; + GL.currentContext.tempVertexBuffers2 = vb; + vb = GL.currentContext.tempVertexBufferCounters1; + GL.currentContext.tempVertexBufferCounters1 = GL.currentContext.tempVertexBufferCounters2; + GL.currentContext.tempVertexBufferCounters2 = vb; + var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE); + for (var i = 0; i <= largestIndex; ++i) { + GL.currentContext.tempVertexBufferCounters1[i] = 0; + } + }, + getSource: function (shader, count, string, length) { + var source = ""; + for (var i = 0; i < count; ++i) { + var len = length ? HEAP32[(length + i * 4) >> 2] : -1; + source += UTF8ToString(HEAP32[(string + i * 4) >> 2], len < 0 ? undefined : len); + } + return source; + }, + calcBufLength: function calcBufLength(size, type, stride, count) { + if (stride > 0) { + return count * stride; + } + var typeSize = GL.byteSizeByType[type - GL.byteSizeByTypeRoot]; + return size * typeSize * count; + }, + usedTempBuffers: [], + preDrawHandleClientVertexAttribBindings: function preDrawHandleClientVertexAttribBindings( + count, + ) { + GL.resetBufferBinding = false; + for (var i = 0; i < GL.currentContext.maxVertexAttribs; ++i) { + var cb = GL.currentContext.clientBuffers[i]; + if (!cb.clientside || !cb.enabled) continue; + GL.resetBufferBinding = true; + var size = GL.calcBufLength(cb.size, cb.type, cb.stride, count); + var buf = GL.getTempVertexBuffer(size); + GLctx.bindBuffer(34962, buf); + GLctx.bufferSubData(34962, 0, HEAPU8.subarray(cb.ptr, cb.ptr + size)); + cb.vertexAttribPointerAdaptor.call( + GLctx, + i, + cb.size, + cb.type, + cb.normalized, + cb.stride, + 0, + ); + } + }, + postDrawHandleClientVertexAttribBindings: + function postDrawHandleClientVertexAttribBindings() { + if (GL.resetBufferBinding) { + GLctx.bindBuffer(34962, GL.buffers[GLctx.currentArrayBufferBinding]); + } + }, + createContext: function (canvas, webGLContextAttributes) { + if (webGLContextAttributes.renderViaOffscreenBackBuffer) + webGLContextAttributes["preserveDrawingBuffer"] = true; + if (!canvas.getContextSafariWebGL2Fixed) { + canvas.getContextSafariWebGL2Fixed = canvas.getContext; + function fixedGetContext(ver, attrs) { + var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs); + return (ver == "webgl") == gl instanceof WebGLRenderingContext ? gl : null; + } + canvas.getContext = fixedGetContext; + } + var ctx = + webGLContextAttributes.majorVersion > 1 + ? canvas.getContext("webgl2", webGLContextAttributes) + : canvas.getContext("webgl", webGLContextAttributes); + if (!ctx) return 0; + var handle = GL.registerContext(ctx, webGLContextAttributes); + return handle; + }, + enableOffscreenFramebufferAttributes: function (webGLContextAttributes) { + webGLContextAttributes.renderViaOffscreenBackBuffer = true; + webGLContextAttributes.preserveDrawingBuffer = true; + }, + createOffscreenFramebuffer: function (context) { + var gl = context.GLctx; + var fbo = gl.createFramebuffer(); + gl.bindFramebuffer(36160, fbo); + context.defaultFbo = fbo; + context.defaultFboForbidBlitFramebuffer = false; + if (gl.getContextAttributes().antialias) { + context.defaultFboForbidBlitFramebuffer = true; + } else { + var firefoxMatch = navigator.userAgent.toLowerCase().match(/firefox\/(\d\d)/); + if (firefoxMatch != null) { + var firefoxVersion = firefoxMatch[1]; + context.defaultFboForbidBlitFramebuffer = firefoxVersion < 67; + } + } + context.defaultColorTarget = gl.createTexture(); + context.defaultDepthTarget = gl.createRenderbuffer(); + GL.resizeOffscreenFramebuffer(context); + gl.bindTexture(3553, context.defaultColorTarget); + gl.texParameteri(3553, 10241, 9728); + gl.texParameteri(3553, 10240, 9728); + gl.texParameteri(3553, 10242, 33071); + gl.texParameteri(3553, 10243, 33071); + gl.texImage2D(3553, 0, 6408, gl.canvas.width, gl.canvas.height, 0, 6408, 5121, null); + gl.framebufferTexture2D(36160, 36064, 3553, context.defaultColorTarget, 0); + gl.bindTexture(3553, null); + var depthTarget = gl.createRenderbuffer(); + gl.bindRenderbuffer(36161, context.defaultDepthTarget); + gl.renderbufferStorage(36161, 33189, gl.canvas.width, gl.canvas.height); + gl.framebufferRenderbuffer(36160, 36096, 36161, context.defaultDepthTarget); + gl.bindRenderbuffer(36161, null); + var vertices = [-1, -1, -1, 1, 1, -1, 1, 1]; + var vb = gl.createBuffer(); + gl.bindBuffer(34962, vb); + gl.bufferData(34962, new Float32Array(vertices), 35044); + gl.bindBuffer(34962, null); + context.blitVB = vb; + var vsCode = + "attribute vec2 pos;" + + "varying lowp vec2 tex;" + + "void main() { tex = pos * 0.5 + vec2(0.5,0.5); gl_Position = vec4(pos, 0.0, 1.0); }"; + var vs = gl.createShader(35633); + gl.shaderSource(vs, vsCode); + gl.compileShader(vs); + var fsCode = + "varying lowp vec2 tex;" + + "uniform sampler2D sampler;" + + "void main() { gl_FragColor = texture2D(sampler, tex); }"; + var fs = gl.createShader(35632); + gl.shaderSource(fs, fsCode); + gl.compileShader(fs); + var blitProgram = gl.createProgram(); + gl.attachShader(blitProgram, vs); + gl.attachShader(blitProgram, fs); + gl.linkProgram(blitProgram); + context.blitProgram = blitProgram; + context.blitPosLoc = gl.getAttribLocation(blitProgram, "pos"); + gl.useProgram(blitProgram); + gl.uniform1i(gl.getUniformLocation(blitProgram, "sampler"), 0); + gl.useProgram(null); + context.defaultVao = undefined; + if (gl.createVertexArray) { + context.defaultVao = gl.createVertexArray(); + gl.bindVertexArray(context.defaultVao); + gl.enableVertexAttribArray(context.blitPosLoc); + gl.bindVertexArray(null); + } + }, + resizeOffscreenFramebuffer: function (context) { + var gl = context.GLctx; + if (context.defaultColorTarget) { + var prevTextureBinding = gl.getParameter(32873); + gl.bindTexture(3553, context.defaultColorTarget); + gl.texImage2D( + 3553, + 0, + 6408, + gl.drawingBufferWidth, + gl.drawingBufferHeight, + 0, + 6408, + 5121, + null, + ); + gl.bindTexture(3553, prevTextureBinding); + } + if (context.defaultDepthTarget) { + var prevRenderBufferBinding = gl.getParameter(36007); + gl.bindRenderbuffer(36161, context.defaultDepthTarget); + gl.renderbufferStorage(36161, 33189, gl.drawingBufferWidth, gl.drawingBufferHeight); + gl.bindRenderbuffer(36161, prevRenderBufferBinding); + } + }, + blitOffscreenFramebuffer: function (context) { + var gl = context.GLctx; + var prevScissorTest = gl.getParameter(3089); + if (prevScissorTest) gl.disable(3089); + var prevFbo = gl.getParameter(36006); + if (gl.blitFramebuffer && !context.defaultFboForbidBlitFramebuffer) { + gl.bindFramebuffer(36008, context.defaultFbo); + gl.bindFramebuffer(36009, null); + gl.blitFramebuffer( + 0, + 0, + gl.canvas.width, + gl.canvas.height, + 0, + 0, + gl.canvas.width, + gl.canvas.height, + 16384, + 9728, + ); + } else { + gl.bindFramebuffer(36160, null); + var prevProgram = gl.getParameter(35725); + gl.useProgram(context.blitProgram); + var prevVB = gl.getParameter(34964); + gl.bindBuffer(34962, context.blitVB); + var prevActiveTexture = gl.getParameter(34016); + gl.activeTexture(33984); + var prevTextureBinding = gl.getParameter(32873); + gl.bindTexture(3553, context.defaultColorTarget); + var prevBlend = gl.getParameter(3042); + if (prevBlend) gl.disable(3042); + var prevCullFace = gl.getParameter(2884); + if (prevCullFace) gl.disable(2884); + var prevDepthTest = gl.getParameter(2929); + if (prevDepthTest) gl.disable(2929); + var prevStencilTest = gl.getParameter(2960); + if (prevStencilTest) gl.disable(2960); + function draw() { + gl.vertexAttribPointer(context.blitPosLoc, 2, 5126, false, 0, 0); + gl.drawArrays(5, 0, 4); + } + if (context.defaultVao) { + var prevVAO = gl.getParameter(34229); + gl.bindVertexArray(context.defaultVao); + draw(); + gl.bindVertexArray(prevVAO); + } else { + var prevVertexAttribPointer = { + buffer: gl.getVertexAttrib(context.blitPosLoc, 34975), + size: gl.getVertexAttrib(context.blitPosLoc, 34339), + stride: gl.getVertexAttrib(context.blitPosLoc, 34340), + type: gl.getVertexAttrib(context.blitPosLoc, 34341), + normalized: gl.getVertexAttrib(context.blitPosLoc, 34922), + pointer: gl.getVertexAttribOffset(context.blitPosLoc, 34373), + }; + var maxVertexAttribs = gl.getParameter(34921); + var prevVertexAttribEnables = []; + for (var i = 0; i < maxVertexAttribs; ++i) { + var prevEnabled = gl.getVertexAttrib(i, 34338); + var wantEnabled = i == context.blitPosLoc; + if (prevEnabled && !wantEnabled) { + gl.disableVertexAttribArray(i); + } + if (!prevEnabled && wantEnabled) { + gl.enableVertexAttribArray(i); + } + prevVertexAttribEnables[i] = prevEnabled; + } + draw(); + for (var i = 0; i < maxVertexAttribs; ++i) { + var prevEnabled = prevVertexAttribEnables[i]; + var nowEnabled = i == context.blitPosLoc; + if (prevEnabled && !nowEnabled) { + gl.enableVertexAttribArray(i); + } + if (!prevEnabled && nowEnabled) { + gl.disableVertexAttribArray(i); + } + } + gl.bindBuffer(34962, prevVertexAttribPointer.buffer); + gl.vertexAttribPointer( + context.blitPosLoc, + prevVertexAttribPointer.size, + prevVertexAttribPointer.type, + prevVertexAttribPointer.normalized, + prevVertexAttribPointer.stride, + prevVertexAttribPointer.offset, + ); + } + if (prevStencilTest) gl.enable(2960); + if (prevDepthTest) gl.enable(2929); + if (prevCullFace) gl.enable(2884); + if (prevBlend) gl.enable(3042); + gl.bindTexture(3553, prevTextureBinding); + gl.activeTexture(prevActiveTexture); + gl.bindBuffer(34962, prevVB); + gl.useProgram(prevProgram); + } + gl.bindFramebuffer(36160, prevFbo); + if (prevScissorTest) gl.enable(3089); + }, + registerContext: function (ctx, webGLContextAttributes) { + var handle = GL.getNewId(GL.contexts); + var context = { + handle: handle, + attributes: webGLContextAttributes, + version: webGLContextAttributes.majorVersion, + GLctx: ctx, + }; + if (ctx.canvas) ctx.canvas.GLctxObject = context; + GL.contexts[handle] = context; + if ( + typeof webGLContextAttributes.enableExtensionsByDefault == "undefined" || + webGLContextAttributes.enableExtensionsByDefault + ) { + GL.initExtensions(context); + } + context.maxVertexAttribs = context.GLctx.getParameter(34921); + context.clientBuffers = []; + for (var i = 0; i < context.maxVertexAttribs; i++) { + context.clientBuffers[i] = { + enabled: false, + clientside: false, + size: 0, + type: 0, + normalized: 0, + stride: 0, + ptr: 0, + vertexAttribPointerAdaptor: null, + }; + } + GL.generateTempBuffers(false, context); + if (webGLContextAttributes.renderViaOffscreenBackBuffer) + GL.createOffscreenFramebuffer(context); + return handle; + }, + makeContextCurrent: function (contextHandle) { + GL.currentContext = GL.contexts[contextHandle]; + Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx; + return !(contextHandle && !GLctx); + }, + getContext: function (contextHandle) { + return GL.contexts[contextHandle]; + }, + deleteContext: function (contextHandle) { + if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null; + if (typeof JSEvents == "object") + JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas); + if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) + GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined; + GL.contexts[contextHandle] = null; + }, + initExtensions: function (context) { + if (!context) context = GL.currentContext; + if (context.initExtensionsDone) return; + context.initExtensionsDone = true; + var GLctx = context.GLctx; + __webgl_enable_ANGLE_instanced_arrays(GLctx); + __webgl_enable_OES_vertex_array_object(GLctx); + __webgl_enable_WEBGL_draw_buffers(GLctx); + __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx); + __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx); + if (context.version >= 2) { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2"); + } + if (context.version < 2 || !GLctx.disjointTimerQueryExt) { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query"); + } + __webgl_enable_WEBGL_multi_draw(GLctx); + var exts = GLctx.getSupportedExtensions() || []; + exts.forEach(function (ext) { + if (!ext.includes("lose_context") && !ext.includes("debug")) { + GLctx.getExtension(ext); + } + }); + }, + }; + var JSEvents = { + inEventHandler: 0, + removeAllEventListeners: function () { + for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) { + JSEvents._removeHandler(i); + } + JSEvents.eventHandlers = []; + JSEvents.deferredCalls = []; + }, + registerRemoveEventListeners: function () { + if (!JSEvents.removeEventListenersRegistered) { + __ATEXIT__.push(JSEvents.removeAllEventListeners); + JSEvents.removeEventListenersRegistered = true; + } + }, + deferredCalls: [], + deferCall: function (targetFunction, precedence, argsList) { + function arraysHaveEqualContent(arrA, arrB) { + if (arrA.length != arrB.length) return false; + for (var i in arrA) { + if (arrA[i] != arrB[i]) return false; + } + return true; + } + for (var i in JSEvents.deferredCalls) { + var call = JSEvents.deferredCalls[i]; + if ( + call.targetFunction == targetFunction && + arraysHaveEqualContent(call.argsList, argsList) + ) { + return; + } + } + JSEvents.deferredCalls.push({ + targetFunction: targetFunction, + precedence: precedence, + argsList: argsList, + }); + JSEvents.deferredCalls.sort(function (x, y) { + return x.precedence < y.precedence; + }); + }, + removeDeferredCalls: function (targetFunction) { + for (var i = 0; i < JSEvents.deferredCalls.length; ++i) { + if (JSEvents.deferredCalls[i].targetFunction == targetFunction) { + JSEvents.deferredCalls.splice(i, 1); + --i; + } + } + }, + canPerformEventHandlerRequests: function () { + return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls; + }, + runDeferredCalls: function () { + if (!JSEvents.canPerformEventHandlerRequests()) { + return; + } + for (var i = 0; i < JSEvents.deferredCalls.length; ++i) { + var call = JSEvents.deferredCalls[i]; + JSEvents.deferredCalls.splice(i, 1); + --i; + call.targetFunction.apply(null, call.argsList); + } + }, + eventHandlers: [], + removeAllHandlersOnTarget: function (target, eventTypeString) { + for (var i = 0; i < JSEvents.eventHandlers.length; ++i) { + if ( + JSEvents.eventHandlers[i].target == target && + (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString) + ) { + JSEvents._removeHandler(i--); + } + } + }, + _removeHandler: function (i) { + var h = JSEvents.eventHandlers[i]; + h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture); + JSEvents.eventHandlers.splice(i, 1); + }, + registerOrRemoveHandler: function (eventHandler) { + var jsEventHandler = function jsEventHandler(event) { + ++JSEvents.inEventHandler; + JSEvents.currentEventHandler = eventHandler; + JSEvents.runDeferredCalls(); + eventHandler.handlerFunc(event); + JSEvents.runDeferredCalls(); + --JSEvents.inEventHandler; + }; + if (eventHandler.callbackfunc) { + eventHandler.eventListenerFunc = jsEventHandler; + eventHandler.target.addEventListener( + eventHandler.eventTypeString, + jsEventHandler, + eventHandler.useCapture, + ); + JSEvents.eventHandlers.push(eventHandler); + JSEvents.registerRemoveEventListeners(); + } else { + for (var i = 0; i < JSEvents.eventHandlers.length; ++i) { + if ( + JSEvents.eventHandlers[i].target == eventHandler.target && + JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString + ) { + JSEvents._removeHandler(i--); + } + } + } + }, + getNodeNameForTarget: function (target) { + if (!target) return ""; + if (target == window) return "#window"; + if (target == screen) return "#screen"; + return target && target.nodeName ? target.nodeName : ""; + }, + fullscreenEnabled: function () { + return document.fullscreenEnabled || document.webkitFullscreenEnabled; + }, + }; + var __emscripten_webgl_power_preferences = ["default", "low-power", "high-performance"]; + var specialHTMLTargets = [ + 0, + typeof document != "undefined" ? document : 0, + typeof window != "undefined" ? window : 0, + ]; + function findEventTarget(target) { + warnOnce( + "Rules for selecting event targets in HTML5 API are changing: instead of using document.getElementById() that only can refer to elements by their DOM ID, new event target selection mechanism uses the more flexible function document.querySelector() that can look up element names, classes, and complex CSS selectors. Build with -sDISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR to change to the new lookup rules. See https://github.com/emscripten-core/emscripten/pull/7977 for more details.", + ); + try { + if (!target) return window; + if (typeof target == "number") target = specialHTMLTargets[target] || UTF8ToString(target); + if (target === "#window") return window; + else if (target === "#document") return document; + else if (target === "#screen") return screen; + else if (target === "#canvas") return Module["canvas"]; + return typeof target == "string" ? document.getElementById(target) : target; + } catch (e) { + return null; + } + } + function findCanvasEventTarget(target) { + if (typeof target == "number") target = UTF8ToString(target); + if (!target || target === "#canvas") { + if (typeof GL != "undefined" && GL.offscreenCanvases["canvas"]) + return GL.offscreenCanvases["canvas"]; + return Module["canvas"]; + } + if (typeof GL != "undefined" && GL.offscreenCanvases[target]) + return GL.offscreenCanvases[target]; + return findEventTarget(target); + } + function _emscripten_webgl_do_create_context(target, attributes) { + assert(attributes); + var a = attributes >> 2; + var powerPreference = HEAP32[a + (24 >> 2)]; + var contextAttributes = { + alpha: !!HEAP32[a + (0 >> 2)], + depth: !!HEAP32[a + (4 >> 2)], + stencil: !!HEAP32[a + (8 >> 2)], + antialias: !!HEAP32[a + (12 >> 2)], + premultipliedAlpha: !!HEAP32[a + (16 >> 2)], + preserveDrawingBuffer: !!HEAP32[a + (20 >> 2)], + powerPreference: __emscripten_webgl_power_preferences[powerPreference], + failIfMajorPerformanceCaveat: !!HEAP32[a + (28 >> 2)], + majorVersion: HEAP32[a + (32 >> 2)], + minorVersion: HEAP32[a + (36 >> 2)], + enableExtensionsByDefault: HEAP32[a + (40 >> 2)], + explicitSwapControl: HEAP32[a + (44 >> 2)], + proxyContextToMainThread: HEAP32[a + (48 >> 2)], + renderViaOffscreenBackBuffer: HEAP32[a + (52 >> 2)], + }; + var canvas = findCanvasEventTarget(target); + if (!canvas) { + return 0; + } + if (canvas.offscreenCanvas) canvas = canvas.offscreenCanvas; + if (contextAttributes.explicitSwapControl) { + var supportsOffscreenCanvas = + canvas.transferControlToOffscreen || + (typeof OffscreenCanvas != "undefined" && canvas instanceof OffscreenCanvas); + if (!supportsOffscreenCanvas) { + if (!contextAttributes.renderViaOffscreenBackBuffer) { + contextAttributes.renderViaOffscreenBackBuffer = true; + } + } + if (canvas.transferControlToOffscreen) { + if (!canvas.controlTransferredOffscreen) { + GL.offscreenCanvases[canvas.id] = { + canvas: canvas.transferControlToOffscreen(), + canvasSharedPtr: _malloc(12), + id: canvas.id, + }; + canvas.controlTransferredOffscreen = true; + } else if (!GL.offscreenCanvases[canvas.id]) { + return 0; + } + canvas = GL.offscreenCanvases[canvas.id]; + } + } + var contextHandle = GL.createContext(canvas, contextAttributes); + return contextHandle; + } + var _emscripten_webgl_create_context = _emscripten_webgl_do_create_context; + function _emscripten_webgl_destroy_context(contextHandle) { + if (GL.currentContext == contextHandle) GL.currentContext = 0; + GL.deleteContext(contextHandle); + } + function _emscripten_webgl_get_context_attributes(c, a) { + if (!a) return -5; + c = GL.contexts[c]; + if (!c) return -3; + var t = c.GLctx; + if (!t) return -3; + t = t.getContextAttributes(); + HEAP32[a >> 2] = t.alpha; + HEAP32[(a + 4) >> 2] = t.depth; + HEAP32[(a + 8) >> 2] = t.stencil; + HEAP32[(a + 12) >> 2] = t.antialias; + HEAP32[(a + 16) >> 2] = t.premultipliedAlpha; + HEAP32[(a + 20) >> 2] = t.preserveDrawingBuffer; + var power = + t["powerPreference"] && __emscripten_webgl_power_preferences.indexOf(t["powerPreference"]); + HEAP32[(a + 24) >> 2] = power; + HEAP32[(a + 28) >> 2] = t.failIfMajorPerformanceCaveat; + HEAP32[(a + 32) >> 2] = c.version; + HEAP32[(a + 36) >> 2] = 0; + HEAP32[(a + 40) >> 2] = c.attributes.enableExtensionsByDefault; + return 0; + } + function _emscripten_webgl_do_get_current_context() { + return GL.currentContext ? GL.currentContext.handle : 0; + } + var _emscripten_webgl_get_current_context = _emscripten_webgl_do_get_current_context; + function _emscripten_webgl_init_context_attributes(attributes) { + assert(attributes); + var a = attributes >> 2; + for (var i = 0; i < 56 >> 2; ++i) { + HEAP32[a + i] = 0; + } + HEAP32[a + (0 >> 2)] = + HEAP32[a + (4 >> 2)] = + HEAP32[a + (12 >> 2)] = + HEAP32[a + (16 >> 2)] = + HEAP32[a + (32 >> 2)] = + HEAP32[a + (40 >> 2)] = + 1; + } + function _emscripten_webgl_make_context_current(contextHandle) { + var success = GL.makeContextCurrent(contextHandle); + return success ? 0 : -5; + } + var WebGPU = { + initManagers: function () { + if (WebGPU.mgrDevice) return; + function Manager() { + this.objects = {}; + this.nextId = 1; + this.create = function (object, wrapper) { + wrapper = wrapper || {}; + var id = this.nextId++; + assert(typeof this.objects[id] == "undefined"); + wrapper.refcount = 1; + wrapper.object = object; + this.objects[id] = wrapper; + return id; + }; + this.get = function (id) { + if (!id) return undefined; + var o = this.objects[id]; + assert(typeof o != "undefined"); + return o.object; + }; + this.reference = function (id) { + var o = this.objects[id]; + assert(typeof o != "undefined"); + o.refcount++; + }; + this.release = function (id) { + var o = this.objects[id]; + assert(typeof o != "undefined"); + assert(o.refcount > 0); + o.refcount--; + if (o.refcount <= 0) { + delete this.objects[id]; + } + }; + } + WebGPU.mgrSurface = WebGPU.mgrSurface || new Manager(); + WebGPU.mgrSwapChain = WebGPU.mgrSwapChain || new Manager(); + WebGPU.mgrAdapter = WebGPU.mgrAdapter || new Manager(); + WebGPU.mgrDevice = WebGPU.mgrDevice || new Manager(); + WebGPU.mgrQueue = WebGPU.mgrQueue || new Manager(); + WebGPU.mgrCommandBuffer = WebGPU.mgrCommandBuffer || new Manager(); + WebGPU.mgrCommandEncoder = WebGPU.mgrCommandEncoder || new Manager(); + WebGPU.mgrRenderPassEncoder = WebGPU.mgrRenderPassEncoder || new Manager(); + WebGPU.mgrComputePassEncoder = WebGPU.mgrComputePassEncoder || new Manager(); + WebGPU.mgrBindGroup = WebGPU.mgrBindGroup || new Manager(); + WebGPU.mgrBuffer = WebGPU.mgrBuffer || new Manager(); + WebGPU.mgrSampler = WebGPU.mgrSampler || new Manager(); + WebGPU.mgrTexture = WebGPU.mgrTexture || new Manager(); + WebGPU.mgrTextureView = WebGPU.mgrTextureView || new Manager(); + WebGPU.mgrQuerySet = WebGPU.mgrQuerySet || new Manager(); + WebGPU.mgrBindGroupLayout = WebGPU.mgrBindGroupLayout || new Manager(); + WebGPU.mgrPipelineLayout = WebGPU.mgrPipelineLayout || new Manager(); + WebGPU.mgrRenderPipeline = WebGPU.mgrRenderPipeline || new Manager(); + WebGPU.mgrComputePipeline = WebGPU.mgrComputePipeline || new Manager(); + WebGPU.mgrShaderModule = WebGPU.mgrShaderModule || new Manager(); + WebGPU.mgrRenderBundleEncoder = WebGPU.mgrRenderBundleEncoder || new Manager(); + WebGPU.mgrRenderBundle = WebGPU.mgrRenderBundle || new Manager(); + }, + makeColor: function (ptr) { + return { + r: HEAPF64[ptr >> 3], + g: HEAPF64[(ptr + 8) >> 3], + b: HEAPF64[(ptr + 16) >> 3], + a: HEAPF64[(ptr + 24) >> 3], + }; + }, + makeExtent3D: function (ptr) { + return { + width: HEAPU32[ptr >> 2], + height: HEAPU32[(ptr + 4) >> 2], + depthOrArrayLayers: HEAPU32[(ptr + 8) >> 2], + }; + }, + makeOrigin3D: function (ptr) { + return { x: HEAPU32[ptr >> 2], y: HEAPU32[(ptr + 4) >> 2], z: HEAPU32[(ptr + 8) >> 2] }; + }, + makeImageCopyTexture: function (ptr) { + assert(ptr); + assert(HEAPU32[ptr >> 2] === 0); + return { + texture: WebGPU.mgrTexture.get(HEAPU32[(ptr + 4) >> 2]), + mipLevel: HEAPU32[(ptr + 8) >> 2], + origin: WebGPU.makeOrigin3D(ptr + 12), + aspect: WebGPU.TextureAspect[HEAPU32[(ptr + 24) >> 2]], + }; + }, + makeTextureDataLayout: function (ptr) { + assert(ptr); + assert(HEAPU32[ptr >> 2] === 0); + var bytesPerRow = HEAPU32[(ptr + 16) >> 2]; + var rowsPerImage = HEAPU32[(ptr + 20) >> 2]; + return { + offset: HEAPU32[(ptr + 4 + 8) >> 2] * 4294967296 + HEAPU32[(ptr + 8) >> 2], + bytesPerRow: bytesPerRow === 4294967295 ? undefined : bytesPerRow, + rowsPerImage: rowsPerImage === 4294967295 ? undefined : rowsPerImage, + }; + }, + makeImageCopyBuffer: function (ptr) { + assert(ptr); + assert(HEAPU32[ptr >> 2] === 0); + var layoutPtr = ptr + 8; + var bufferCopyView = WebGPU.makeTextureDataLayout(layoutPtr); + bufferCopyView["buffer"] = WebGPU.mgrBuffer.get(HEAPU32[(ptr + 32) >> 2]); + return bufferCopyView; + }, + makePipelineConstants: function (constantCount, constantsPtr) { + if (!constantCount) return; + var constants = {}; + for (var i = 0; i < constantCount; ++i) { + var entryPtr = constantsPtr + 16 * i; + var key = UTF8ToString(HEAPU32[(entryPtr + 4) >> 2]); + constants[key] = HEAPF64[(entryPtr + 8) >> 3]; + } + return constants; + }, + makeProgrammableStageDescriptor: function (ptr) { + if (!ptr) return undefined; + assert(ptr); + assert(HEAPU32[ptr >> 2] === 0); + return { + module: WebGPU.mgrShaderModule.get(HEAPU32[(ptr + 4) >> 2]), + entryPoint: UTF8ToString(HEAPU32[(ptr + 8) >> 2]), + constants: WebGPU.makePipelineConstants( + HEAPU32[(ptr + 12) >> 2], + HEAPU32[(ptr + 16) >> 2], + ), + }; + }, + DeviceLostReason: { undefined: 0, destroyed: 1 }, + PreferredFormat: { rgba8unorm: 18, bgra8unorm: 23 }, + AddressMode: ["repeat", "mirror-repeat", "clamp-to-edge"], + BlendFactor: [ + "zero", + "one", + "src", + "one-minus-src", + "src-alpha", + "one-minus-src-alpha", + "dst", + "one-minus-dst", + "dst-alpha", + "one-minus-dst-alpha", + "src-alpha-saturated", + "constant", + "one-minus-constant", + ], + BlendOperation: ["add", "subtract", "reverse-subtract", "min", "max"], + BufferBindingType: [, "uniform", "storage", "read-only-storage"], + CompareFunction: [ + , + "never", + "less", + "less-equal", + "greater", + "greater-equal", + "equal", + "not-equal", + "always", + ], + CompilationInfoRequestStatus: ["success", "error", "device-lost", "unknown"], + ComputePassTimestampLocation: ["beginning", "end"], + CullMode: ["none", "front", "back"], + ErrorFilter: ["validation", "out-of-memory"], + FeatureName: [ + , + "depth-clip-control", + "depth32float-stencil8", + "timestamp-query", + "pipeline-statistics-query", + "texture-compression-bc", + "texture-compression-etc2", + "texture-compression-astc", + "indirect-first-instance", + ], + FilterMode: ["nearest", "linear"], + FrontFace: ["ccw", "cw"], + IndexFormat: [, "uint16", "uint32"], + LoadOp: [, "clear", "load"], + PipelineStatisticName: [ + "vertex-shader-invocations", + "clipper-invocations", + "clipper-primitives-out", + "fragment-shader-invocations", + "compute-shader-invocations", + ], + PowerPreference: [, "low-power", "high-performance"], + PrimitiveTopology: [ + "point-list", + "line-list", + "line-strip", + "triangle-list", + "triangle-strip", + ], + QueryType: ["occlusion", "pipeline-statistics", "timestamp"], + RenderPassTimestampLocation: ["beginning", "end"], + SamplerBindingType: [, "filtering", "non-filtering", "comparison"], + StencilOperation: [ + "keep", + "zero", + "replace", + "invert", + "increment-clamp", + "decrement-clamp", + "increment-wrap", + "decrement-wrap", + ], + StorageTextureAccess: [, "write-only"], + StoreOp: [, "store", "discard"], + TextureAspect: ["all", "stencil-only", "depth-only"], + TextureComponentType: ["float", "sint", "uint", "depth-comparison"], + TextureDimension: ["1d", "2d", "3d"], + TextureFormat: [ + , + "r8unorm", + "r8snorm", + "r8uint", + "r8sint", + "r16uint", + "r16sint", + "r16float", + "rg8unorm", + "rg8snorm", + "rg8uint", + "rg8sint", + "r32float", + "r32uint", + "r32sint", + "rg16uint", + "rg16sint", + "rg16float", + "rgba8unorm", + "rgba8unorm-srgb", + "rgba8snorm", + "rgba8uint", + "rgba8sint", + "bgra8unorm", + "bgra8unorm-srgb", + "rgb10a2unorm", + "rg11b10ufloat", + "rgb9e5ufloat", + "rg32float", + "rg32uint", + "rg32sint", + "rgba16uint", + "rgba16sint", + "rgba16float", + "rgba32float", + "rgba32uint", + "rgba32sint", + "stencil8", + "depth16unorm", + "depth24plus", + "depth24plus-stencil8", + "depth32float", + "depth32float-stencil8", + "bc1-rgba-unorm", + "bc1-rgba-unorm-srgb", + "bc2-rgba-unorm", + "bc2-rgba-unorm-srgb", + "bc3-rgba-unorm", + "bc3-rgba-unorm-srgb", + "bc4-r-unorm", + "bc4-r-snorm", + "bc5-rg-unorm", + "bc5-rg-snorm", + "bc6h-rgb-ufloat", + "bc6h-rgb-float", + "bc7-rgba-unorm", + "bc7-rgba-unorm-srgb", + "etc2-rgb8unorm", + "etc2-rgb8unorm-srgb", + "etc2-rgb8a1unorm", + "etc2-rgb8a1unorm-srgb", + "etc2-rgba8unorm", + "etc2-rgba8unorm-srgb", + "eac-r11unorm", + "eac-r11snorm", + "eac-rg11unorm", + "eac-rg11snorm", + "astc-4x4-unorm", + "astc-4x4-unorm-srgb", + "astc-5x4-unorm", + "astc-5x4-unorm-srgb", + "astc-5x5-unorm", + "astc-5x5-unorm-srgb", + "astc-6x5-unorm", + "astc-6x5-unorm-srgb", + "astc-6x6-unorm", + "astc-6x6-unorm-srgb", + "astc-8x5-unorm", + "astc-8x5-unorm-srgb", + "astc-8x6-unorm", + "astc-8x6-unorm-srgb", + "astc-8x8-unorm", + "astc-8x8-unorm-srgb", + "astc-10x5-unorm", + "astc-10x5-unorm-srgb", + "astc-10x6-unorm", + "astc-10x6-unorm-srgb", + "astc-10x8-unorm", + "astc-10x8-unorm-srgb", + "astc-10x10-unorm", + "astc-10x10-unorm-srgb", + "astc-12x10-unorm", + "astc-12x10-unorm-srgb", + "astc-12x12-unorm", + "astc-12x12-unorm-srgb", + ], + TextureSampleType: [, "float", "unfilterable-float", "depth", "sint", "uint"], + TextureViewDimension: [, "1d", "2d", "2d-array", "cube", "cube-array", "3d"], + VertexFormat: [ + , + "uint8x2", + "uint8x4", + "sint8x2", + "sint8x4", + "unorm8x2", + "unorm8x4", + "snorm8x2", + "snorm8x4", + "uint16x2", + "uint16x4", + "sint16x2", + "sint16x4", + "unorm16x2", + "unorm16x4", + "snorm16x2", + "snorm16x4", + "float16x2", + "float16x4", + "float32", + "float32x2", + "float32x3", + "float32x4", + "uint32", + "uint32x2", + "uint32x3", + "uint32x4", + "sint32", + "sint32x2", + "sint32x3", + "sint32x4", + ], + VertexStepMode: ["vertex", "instance"], + FeatureNameString2Enum: { + undefined: "0", + "depth-clip-control": "1", + "depth32float-stencil8": "2", + "timestamp-query": "3", + "pipeline-statistics-query": "4", + "texture-compression-bc": "5", + "texture-compression-etc2": "6", + "texture-compression-astc": "7", + "indirect-first-instance": "8", + }, + }; + var JsValStore = { + values: {}, + next_id: 1, + add: function (js_val) { + var id; + do { + id = JsValStore.next_id++; + if (JsValStore.next_id > 2147483647) JsValStore.next_id = 1; + } while (id in JsValStore.values); + JsValStore.values[id] = js_val; + return id; + }, + remove: function (id) { + assert(id in JsValStore.values); + delete JsValStore.values[id]; + }, + get: function (id) { + assert(id === 0 || id in JsValStore.values); + return JsValStore.values[id]; + }, + }; + function _emscripten_webgpu_export_bind_group_layout(handle) { + return JsValStore.add(WebGPU.mgrBindGroupLayout.get(handle)); + } + function _emscripten_webgpu_export_device(handle) { + return JsValStore.add(WebGPU.mgrDevice.get(handle)); + } + function _emscripten_webgpu_export_sampler(handle) { + return JsValStore.add(WebGPU.mgrSampler.get(handle)); + } + function _emscripten_webgpu_export_texture(handle) { + return JsValStore.add(WebGPU.mgrTexture.get(handle)); + } + function _emscripten_webgpu_get_device() { + assert(Module["preinitializedWebGPUDevice"]); + if (WebGPU.preinitializedDeviceId === undefined) { + var device = Module["preinitializedWebGPUDevice"]; + var deviceWrapper = { queueId: WebGPU.mgrQueue.create(device["queue"]) }; + WebGPU.preinitializedDeviceId = WebGPU.mgrDevice.create(device, deviceWrapper); + } + WebGPU.mgrDevice.reference(WebGPU.preinitializedDeviceId); + return WebGPU.preinitializedDeviceId; + } + function _emscripten_webgpu_import_bind_group(handle) { + return WebGPU.mgrBindGroup.create(JsValStore.get(handle)); + } + function _emscripten_webgpu_import_texture(handle) { + return WebGPU.mgrTexture.create(JsValStore.get(handle)); + } + function _emscripten_webgpu_release_js_handle(id) { + JsValStore.remove(id); + } + var ENV = {}; + function getExecutableName() { + return thisProgram || "./this.program"; + } + function getEnvStrings() { + if (!getEnvStrings.strings) { + var lang = + ( + (typeof navigator == "object" && navigator.languages && navigator.languages[0]) || + "C" + ).replace("-", "_") + ".UTF-8"; + var env = { + USER: "web_user", + LOGNAME: "web_user", + PATH: "/", + PWD: "/", + HOME: "/home/web_user", + LANG: lang, + _: getExecutableName(), + }; + for (var x in ENV) { + if (ENV[x] === undefined) delete env[x]; + else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + "=" + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + } + function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === (str.charCodeAt(i) & 255)); + HEAP8[buffer++ >> 0] = str.charCodeAt(i); + } + if (!dontAddNull) HEAP8[buffer >> 0] = 0; + } + function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function (string, i) { + var ptr = environ_buf + bufSize; + HEAPU32[(__environ + i * 4) >> 2] = ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1; + }); + return 0; + } + function _environ_sizes_get(penviron_count, penviron_buf_size) { + var strings = getEnvStrings(); + HEAPU32[penviron_count >> 2] = strings.length; + var bufSize = 0; + strings.forEach(function (string) { + bufSize += string.length + 1; + }); + HEAPU32[penviron_buf_size >> 2] = bufSize; + return 0; + } + function _fd_close(fd) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + function doReadv(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[iov >> 2]; + var len = HEAPU32[(iov + 4) >> 2]; + iov += 8; + var curr = FS.read(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; + } + return ret; + } + function _fd_read(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAPU32[pnum >> 2] = num; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + function convertI32PairToI53Checked(lo, hi) { + assert(lo == lo >>> 0 || lo == (lo | 0)); + assert(hi === (hi | 0)); + return (hi + 2097152) >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN; + } + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + var offset = convertI32PairToI53Checked(offset_low, offset_high); + if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + (tempI64 = [ + stream.position >>> 0, + ((tempDouble = stream.position), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[newOffset >> 2] = tempI64[0]), + (HEAP32[(newOffset + 4) >> 2] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + function doWritev(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[iov >> 2]; + var len = HEAPU32[(iov + 4) >> 2]; + iov += 8; + var curr = FS.write(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + } + return ret; + } + function _fd_write(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[pnum >> 2] = num; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + function _getentropy(buffer, size) { + if (!_getentropy.randomDevice) { + _getentropy.randomDevice = getRandomDevice(); + } + for (var i = 0; i < size; i++) { + HEAP8[(buffer + i) >> 0] = _getentropy.randomDevice(); + } + return 0; + } + function _glActiveTexture(x0) { + GLctx["activeTexture"](x0); + } + function _glAttachShader(program, shader) { + GLctx.attachShader(GL.programs[program], GL.shaders[shader]); + } + function _glBindAttribLocation(program, index, name) { + GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name)); + } + function _glBindBuffer(target, buffer) { + if (target == 34962) { + GLctx.currentArrayBufferBinding = buffer; + } else if (target == 34963) { + GLctx.currentElementArrayBufferBinding = buffer; + } + if (target == 35051) { + GLctx.currentPixelPackBufferBinding = buffer; + } else if (target == 35052) { + GLctx.currentPixelUnpackBufferBinding = buffer; + } + GLctx.bindBuffer(target, GL.buffers[buffer]); + } + function _glBindBufferBase(target, index, buffer) { + GLctx["bindBufferBase"](target, index, GL.buffers[buffer]); + } + function _glBindFramebuffer(target, framebuffer) { + GLctx.bindFramebuffer( + target, + framebuffer ? GL.framebuffers[framebuffer] : GL.currentContext.defaultFbo, + ); + } + function _glBindTexture(target, texture) { + GLctx.bindTexture(target, GL.textures[texture]); + } + function _glBindVertexArray(vao) { + GLctx["bindVertexArray"](GL.vaos[vao]); + var ibo = GLctx.getParameter(34965); + GLctx.currentElementArrayBufferBinding = ibo ? ibo.name | 0 : 0; + } + function _glBufferData(target, size, data, usage) { + if (GL.currentContext.version >= 2) { + if (data && size) { + GLctx.bufferData(target, HEAPU8, usage, data, size); + } else { + GLctx.bufferData(target, size, usage); + } + } else { + GLctx.bufferData(target, data ? HEAPU8.subarray(data, data + size) : size, usage); + } + } + function convertI32PairToI53(lo, hi) { + assert(hi === (hi | 0)); + return (lo >>> 0) + hi * 4294967296; + } + function _glClientWaitSync(sync, flags, timeoutLo, timeoutHi) { + return GLctx.clientWaitSync(GL.syncs[sync], flags, convertI32PairToI53(timeoutLo, timeoutHi)); + } + function _glCompileShader(shader) { + GLctx.compileShader(GL.shaders[shader]); + } + function _glCreateProgram() { + var id = GL.getNewId(GL.programs); + var program = GLctx.createProgram(); + program.name = id; + program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0; + program.uniformIdCounter = 1; + GL.programs[id] = program; + return id; + } + function _glCreateShader(shaderType) { + var id = GL.getNewId(GL.shaders); + GL.shaders[id] = GLctx.createShader(shaderType); + return id; + } + function _glDeleteBuffers(n, buffers) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(buffers + i * 4) >> 2]; + var buffer = GL.buffers[id]; + if (!buffer) continue; + GLctx.deleteBuffer(buffer); + buffer.name = 0; + GL.buffers[id] = null; + if (id == GLctx.currentArrayBufferBinding) GLctx.currentArrayBufferBinding = 0; + if (id == GLctx.currentElementArrayBufferBinding) + GLctx.currentElementArrayBufferBinding = 0; + if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0; + if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0; + } + } + function _glDeleteFramebuffers(n, framebuffers) { + for (var i = 0; i < n; ++i) { + var id = HEAP32[(framebuffers + i * 4) >> 2]; + var framebuffer = GL.framebuffers[id]; + if (!framebuffer) continue; + GLctx.deleteFramebuffer(framebuffer); + framebuffer.name = 0; + GL.framebuffers[id] = null; + } + } + function _glDeleteProgram(id) { + if (!id) return; + var program = GL.programs[id]; + if (!program) { + GL.recordError(1281); + return; + } + GLctx.deleteProgram(program); + program.name = 0; + GL.programs[id] = null; + } + function _glDeleteShader(id) { + if (!id) return; + var shader = GL.shaders[id]; + if (!shader) { + GL.recordError(1281); + return; + } + GLctx.deleteShader(shader); + GL.shaders[id] = null; + } + function _glDeleteSync(id) { + if (!id) return; + var sync = GL.syncs[id]; + if (!sync) { + GL.recordError(1281); + return; + } + GLctx.deleteSync(sync); + sync.name = 0; + GL.syncs[id] = null; + } + function _glDeleteTextures(n, textures) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(textures + i * 4) >> 2]; + var texture = GL.textures[id]; + if (!texture) continue; + GLctx.deleteTexture(texture); + texture.name = 0; + GL.textures[id] = null; + } + } + function _glDeleteVertexArrays(n, vaos) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(vaos + i * 4) >> 2]; + GLctx["deleteVertexArray"](GL.vaos[id]); + GL.vaos[id] = null; + } + } + function _glDisable(x0) { + GLctx["disable"](x0); + } + function _glDisableVertexAttribArray(index) { + var cb = GL.currentContext.clientBuffers[index]; + cb.enabled = false; + GLctx.disableVertexAttribArray(index); + } + function _glDrawArrays(mode, first, count) { + GL.preDrawHandleClientVertexAttribBindings(first + count); + GLctx.drawArrays(mode, first, count); + GL.postDrawHandleClientVertexAttribBindings(); + } + var tempFixedLengthArray = []; + function _glDrawBuffers(n, bufs) { + var bufArray = tempFixedLengthArray[n]; + for (var i = 0; i < n; i++) { + bufArray[i] = HEAP32[(bufs + i * 4) >> 2]; + } + GLctx["drawBuffers"](bufArray); + } + function _glEnableVertexAttribArray(index) { + var cb = GL.currentContext.clientBuffers[index]; + cb.enabled = true; + GLctx.enableVertexAttribArray(index); + } + function _glFenceSync(condition, flags) { + var sync = GLctx.fenceSync(condition, flags); + if (sync) { + var id = GL.getNewId(GL.syncs); + sync.name = id; + GL.syncs[id] = sync; + return id; + } + return 0; + } + function _glFinish() { + GLctx["finish"](); + } + function _glFlush() { + GLctx["flush"](); + } + function _glFramebufferTexture2D(target, attachment, textarget, texture, level) { + GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level); + } + function _glFramebufferTextureLayer(target, attachment, texture, level, layer) { + GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer); + } + function __glGenObject(n, buffers, createFunction, objectTable) { + for (var i = 0; i < n; i++) { + var buffer = GLctx[createFunction](); + var id = buffer && GL.getNewId(objectTable); + if (buffer) { + buffer.name = id; + objectTable[id] = buffer; + } else { + GL.recordError(1282); + } + HEAP32[(buffers + i * 4) >> 2] = id; + } + } + function _glGenBuffers(n, buffers) { + __glGenObject(n, buffers, "createBuffer", GL.buffers); + } + function _glGenFramebuffers(n, ids) { + __glGenObject(n, ids, "createFramebuffer", GL.framebuffers); + } + function _glGenTextures(n, textures) { + __glGenObject(n, textures, "createTexture", GL.textures); + } + function _glGenVertexArrays(n, arrays) { + __glGenObject(n, arrays, "createVertexArray", GL.vaos); + } + function _glGetAttribLocation(program, name) { + return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name)); + } + function _glGetError() { + var error = GLctx.getError() || GL.lastError; + GL.lastError = 0; + return error; + } + function readI53FromU64(ptr) { + return HEAPU32[ptr >> 2] + HEAPU32[(ptr + 4) >> 2] * 4294967296; + } + function writeI53ToI64(ptr, num) { + HEAPU32[ptr >> 2] = num; + HEAPU32[(ptr + 4) >> 2] = (num - HEAPU32[ptr >> 2]) / 4294967296; + var deserialized = num >= 0 ? readI53FromU64(ptr) : readI53FromI64(ptr); + if (deserialized != num) + warnOnce( + "writeI53ToI64() out of range: serialized JS Number " + + num + + " to Wasm heap as bytes lo=" + + ptrToString(HEAPU32[ptr >> 2]) + + ", hi=" + + ptrToString(HEAPU32[(ptr + 4) >> 2]) + + ", which deserializes back to " + + deserialized + + " instead!", + ); + } + function emscriptenWebGLGet(name_, p, type) { + if (!p) { + GL.recordError(1281); + return; + } + var ret = undefined; + switch (name_) { + case 36346: + ret = 1; + break; + case 36344: + if (type != 0 && type != 1) { + GL.recordError(1280); + } + return; + case 34814: + case 36345: + ret = 0; + break; + case 34466: { + var formats = GLctx.getParameter(34467); + ret = formats ? formats.length : 0; + break; + } + case 33309: { + if (GL.currentContext.version < 2) { + GL.recordError(1282); + return; + } + var exts = GLctx.getSupportedExtensions() || []; + ret = 2 * exts.length; + break; + } + case 33307: + case 33308: + if (GL.currentContext.version < 2) { + GL.recordError(1280); + return; + } + ret = name_ == 33307 ? 3 : 0; + break; + } + if (ret === undefined) { + var result = GLctx.getParameter(name_); + switch (typeof result) { + case "number": + ret = result; + break; + case "boolean": + ret = result ? 1 : 0; + break; + case "string": + GL.recordError(1280); + return; + case "object": + if (result === null) { + switch (name_) { + case 34964: + case 35725: + case 34965: + case 36006: + case 36007: + case 32873: + case 34229: + case 36662: + case 36663: + case 35053: + case 35055: + case 36010: + case 35097: + case 35869: + case 32874: + case 36389: + case 35983: + case 35368: + case 34068: { + ret = 0; + break; + } + default: { + GL.recordError(1280); + return; + } + } + } else if ( + result instanceof Float32Array || + result instanceof Uint32Array || + result instanceof Int32Array || + result instanceof Array + ) { + for (var i = 0; i < result.length; ++i) { + switch (type) { + case 0: + HEAP32[(p + i * 4) >> 2] = result[i]; + break; + case 2: + HEAPF32[(p + i * 4) >> 2] = result[i]; + break; + case 4: + HEAP8[(p + i) >> 0] = result[i] ? 1 : 0; + break; + } + } + return; + } else { + try { + ret = result.name | 0; + } catch (e) { + GL.recordError(1280); + err( + "GL_INVALID_ENUM in glGet" + + type + + "v: Unknown object returned from WebGL getParameter(" + + name_ + + ")! (error: " + + e + + ")", + ); + return; + } + } + break; + default: + GL.recordError(1280); + err( + "GL_INVALID_ENUM in glGet" + + type + + "v: Native code calling glGet" + + type + + "v(" + + name_ + + ") and it returns " + + result + + " of type " + + typeof result + + "!", + ); + return; + } + } + switch (type) { + case 1: + writeI53ToI64(p, ret); + break; + case 0: + HEAP32[p >> 2] = ret; + break; + case 2: + HEAPF32[p >> 2] = ret; + break; + case 4: + HEAP8[p >> 0] = ret ? 1 : 0; + break; + } + } + function _glGetIntegerv(name_, p) { + emscriptenWebGLGet(name_, p, 0); + } + function _glGetProgramiv(program, pname, p) { + if (!p) { + GL.recordError(1281); + return; + } + if (program >= GL.counter) { + GL.recordError(1281); + return; + } + program = GL.programs[program]; + if (pname == 35716) { + var log = GLctx.getProgramInfoLog(program); + if (log === null) log = "(unknown error)"; + HEAP32[p >> 2] = log.length + 1; + } else if (pname == 35719) { + if (!program.maxUniformLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) { + program.maxUniformLength = Math.max( + program.maxUniformLength, + GLctx.getActiveUniform(program, i).name.length + 1, + ); + } + } + HEAP32[p >> 2] = program.maxUniformLength; + } else if (pname == 35722) { + if (!program.maxAttributeLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35721); ++i) { + program.maxAttributeLength = Math.max( + program.maxAttributeLength, + GLctx.getActiveAttrib(program, i).name.length + 1, + ); + } + } + HEAP32[p >> 2] = program.maxAttributeLength; + } else if (pname == 35381) { + if (!program.maxUniformBlockNameLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35382); ++i) { + program.maxUniformBlockNameLength = Math.max( + program.maxUniformBlockNameLength, + GLctx.getActiveUniformBlockName(program, i).length + 1, + ); + } + } + HEAP32[p >> 2] = program.maxUniformBlockNameLength; + } else { + HEAP32[p >> 2] = GLctx.getProgramParameter(program, pname); + } + } + function _glGetShaderInfoLog(shader, maxLength, length, infoLog) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = "(unknown error)"; + var numBytesWrittenExclNull = + maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0; + if (length) HEAP32[length >> 2] = numBytesWrittenExclNull; + } + function _glGetShaderiv(shader, pname, p) { + if (!p) { + GL.recordError(1281); + return; + } + if (pname == 35716) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = "(unknown error)"; + var logLength = log ? log.length + 1 : 0; + HEAP32[p >> 2] = logLength; + } else if (pname == 35720) { + var source = GLctx.getShaderSource(GL.shaders[shader]); + var sourceLength = source ? source.length + 1 : 0; + HEAP32[p >> 2] = sourceLength; + } else { + HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname); + } + } + function stringToNewUTF8(jsString) { + var length = lengthBytesUTF8(jsString) + 1; + var cString = _malloc(length); + stringToUTF8(jsString, cString, length); + return cString; + } + function _glGetString(name_) { + var ret = GL.stringCache[name_]; + if (!ret) { + switch (name_) { + case 7939: { + var exts = GLctx.getSupportedExtensions() || []; + exts = exts.concat( + exts.map(function (e) { + return "GL_" + e; + }), + ); + ret = stringToNewUTF8(exts.join(" ")); + break; + } + case 7936: + case 7937: + case 37445: + case 37446: { + var s = GLctx.getParameter(name_); + if (!s) { + GL.recordError(1280); + } + ret = s && stringToNewUTF8(s); + break; + } + case 7938: { + var glVersion = GLctx.getParameter(7938); + if (GL.currentContext.version >= 2) glVersion = "OpenGL ES 3.0 (" + glVersion + ")"; + else { + glVersion = "OpenGL ES 2.0 (" + glVersion + ")"; + } + ret = stringToNewUTF8(glVersion); + break; + } + case 35724: { + var glslVersion = GLctx.getParameter(35724); + var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/; + var ver_num = glslVersion.match(ver_re); + if (ver_num !== null) { + if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0"; + glslVersion = "OpenGL ES GLSL ES " + ver_num[1] + " (" + glslVersion + ")"; + } + ret = stringToNewUTF8(glslVersion); + break; + } + default: + GL.recordError(1280); + } + GL.stringCache[name_] = ret; + } + return ret; + } + function _glGetUniformBlockIndex(program, uniformBlockName) { + return GLctx["getUniformBlockIndex"](GL.programs[program], UTF8ToString(uniformBlockName)); + } + function jstoi_q(str) { + return parseInt(str); + } + function webglGetLeftBracePos(name) { + return name.slice(-1) == "]" && name.lastIndexOf("["); + } + function webglPrepareUniformLocationsBeforeFirstUse(program) { + var uniformLocsById = program.uniformLocsById, + uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, + i, + j; + if (!uniformLocsById) { + program.uniformLocsById = uniformLocsById = {}; + program.uniformArrayNamesById = {}; + for (i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) { + var u = GLctx.getActiveUniform(program, i); + var nm = u.name; + var sz = u.size; + var lb = webglGetLeftBracePos(nm); + var arrayName = lb > 0 ? nm.slice(0, lb) : nm; + var id = program.uniformIdCounter; + program.uniformIdCounter += sz; + uniformSizeAndIdsByName[arrayName] = [sz, id]; + for (j = 0; j < sz; ++j) { + uniformLocsById[id] = j; + program.uniformArrayNamesById[id++] = arrayName; + } + } + } + } + function _glGetUniformLocation(program, name) { + name = UTF8ToString(name); + if ((program = GL.programs[program])) { + webglPrepareUniformLocationsBeforeFirstUse(program); + var uniformLocsById = program.uniformLocsById; + var arrayIndex = 0; + var uniformBaseName = name; + var leftBrace = webglGetLeftBracePos(name); + if (leftBrace > 0) { + arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0; + uniformBaseName = name.slice(0, leftBrace); + } + var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName]; + if (sizeAndId && arrayIndex < sizeAndId[0]) { + arrayIndex += sizeAndId[1]; + if ( + (uniformLocsById[arrayIndex] = + uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) + ) { + return arrayIndex; + } + } + } else { + GL.recordError(1281); + } + return -1; + } + function _glLinkProgram(program) { + program = GL.programs[program]; + GLctx.linkProgram(program); + program.uniformLocsById = 0; + program.uniformSizeAndIdsByName = {}; + } + function _glPixelStorei(pname, param) { + if (pname == 3317) { + GL.unpackAlignment = param; + } + GLctx.pixelStorei(pname, param); + } + function computeUnpackAlignedImageSize(width, height, sizePerPixel, alignment) { + function roundedToNextMultipleOf(x, y) { + return (x + y - 1) & -y; + } + var plainRowSize = width * sizePerPixel; + var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment); + return height * alignedRowSize; + } + function __colorChannelsInGlTextureFormat(format) { + var colorChannels = { + 5: 3, + 6: 4, + 8: 2, + 29502: 3, + 29504: 4, + 26917: 2, + 26918: 2, + 29846: 3, + 29847: 4, + }; + return colorChannels[format - 6402] || 1; + } + function heapObjectForWebGLType(type) { + type -= 5120; + if (type == 0) return HEAP8; + if (type == 1) return HEAPU8; + if (type == 2) return HEAP16; + if (type == 4) return HEAP32; + if (type == 6) return HEAPF32; + if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) + return HEAPU32; + return HEAPU16; + } + function heapAccessShiftForWebGLHeap(heap) { + return 31 - Math.clz32(heap.BYTES_PER_ELEMENT); + } + function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) { + var heap = heapObjectForWebGLType(type); + var shift = heapAccessShiftForWebGLHeap(heap); + var byteSize = 1 << shift; + var sizePerPixel = __colorChannelsInGlTextureFormat(format) * byteSize; + var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel, GL.unpackAlignment); + return heap.subarray(pixels >> shift, (pixels + bytes) >> shift); + } + function _glReadPixels(x, y, width, height, format, type, pixels) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelPackBufferBinding) { + GLctx.readPixels(x, y, width, height, format, type, pixels); + } else { + var heap = heapObjectForWebGLType(type); + GLctx.readPixels( + x, + y, + width, + height, + format, + type, + heap, + pixels >> heapAccessShiftForWebGLHeap(heap), + ); + } + return; + } + var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format); + if (!pixelData) { + GL.recordError(1280); + return; + } + GLctx.readPixels(x, y, width, height, format, type, pixelData); + } + function _glShaderSource(shader, count, string, length) { + var source = GL.getSource(shader, count, string, length); + GLctx.shaderSource(GL.shaders[shader], source); + } + function _glTexImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + pixels, + ) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + pixels, + ); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + heap, + pixels >> heapAccessShiftForWebGLHeap(heap), + ); + } else { + GLctx.texImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + null, + ); + } + return; + } + GLctx.texImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + pixels + ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) + : null, + ); + } + function _glTexParameterfv(target, pname, params) { + var param = HEAPF32[params >> 2]; + GLctx.texParameterf(target, pname, param); + } + function _glTexParameteri(x0, x1, x2) { + GLctx["texParameteri"](x0, x1, x2); + } + function _glTexStorage2D(x0, x1, x2, x3, x4) { + GLctx["texStorage2D"](x0, x1, x2, x3, x4); + } + function _glTexStorage3D(x0, x1, x2, x3, x4, x5) { + GLctx["texStorage3D"](x0, x1, x2, x3, x4, x5); + } + function _glTexSubImage2D( + target, + level, + xoffset, + yoffset, + width, + height, + format, + type, + pixels, + ) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texSubImage2D( + target, + level, + xoffset, + yoffset, + width, + height, + format, + type, + heap, + pixels >> heapAccessShiftForWebGLHeap(heap), + ); + } else { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, null); + } + return; + } + var pixelData = null; + if (pixels) + pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0); + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData); + } + function _glTexSubImage3D( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type, + pixels, + ) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx["texSubImage3D"]( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type, + pixels, + ); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx["texSubImage3D"]( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type, + heap, + pixels >> heapAccessShiftForWebGLHeap(heap), + ); + } else { + GLctx["texSubImage3D"]( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type, + null, + ); + } + } + function webglGetUniformLocation(location) { + var p = GLctx.currentProgram; + if (p) { + var webglLoc = p.uniformLocsById[location]; + if (typeof webglLoc == "number") { + p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation( + p, + p.uniformArrayNamesById[location] + (webglLoc > 0 ? "[" + webglLoc + "]" : ""), + ); + } + return webglLoc; + } else { + GL.recordError(1282); + } + } + function _glUniform1f(location, v0) { + GLctx.uniform1f(webglGetUniformLocation(location), v0); + } + function _glUniform1i(location, v0) { + GLctx.uniform1i(webglGetUniformLocation(location), v0); + } + var miniTempWebGLFloatBuffers = []; + function _glUniform2fv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && + GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 2); + return; + } + if (count <= 144) { + var view = miniTempWebGLFloatBuffers[2 * count - 1]; + for (var i = 0; i < 2 * count; i += 2) { + view[i] = HEAPF32[(value + 4 * i) >> 2]; + view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2]; + } + } else { + var view = HEAPF32.subarray(value >> 2, (value + count * 8) >> 2); + } + GLctx.uniform2fv(webglGetUniformLocation(location), view); + } + function _glUniform4fv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && + GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 4); + return; + } + if (count <= 72) { + var view = miniTempWebGLFloatBuffers[4 * count - 1]; + var heap = HEAPF32; + value >>= 2; + for (var i = 0; i < 4 * count; i += 4) { + var dst = value + i; + view[i] = heap[dst]; + view[i + 1] = heap[dst + 1]; + view[i + 2] = heap[dst + 2]; + view[i + 3] = heap[dst + 3]; + } + } else { + var view = HEAPF32.subarray(value >> 2, (value + count * 16) >> 2); + } + GLctx.uniform4fv(webglGetUniformLocation(location), view); + } + var __miniTempWebGLIntBuffers = []; + function _glUniform4iv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 4); + return; + } + if (count <= 72) { + var view = __miniTempWebGLIntBuffers[4 * count - 1]; + for (var i = 0; i < 4 * count; i += 4) { + view[i] = HEAP32[(value + 4 * i) >> 2]; + view[i + 1] = HEAP32[(value + (4 * i + 4)) >> 2]; + view[i + 2] = HEAP32[(value + (4 * i + 8)) >> 2]; + view[i + 3] = HEAP32[(value + (4 * i + 12)) >> 2]; + } + } else { + var view = HEAP32.subarray(value >> 2, (value + count * 16) >> 2); + } + GLctx.uniform4iv(webglGetUniformLocation(location), view); + } + function _glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) { + program = GL.programs[program]; + GLctx["uniformBlockBinding"](program, uniformBlockIndex, uniformBlockBinding); + } + function _glUniformMatrix4fv(location, count, transpose, value) { + if (GL.currentContext.version >= 2) { + count && + GLctx.uniformMatrix4fv( + webglGetUniformLocation(location), + !!transpose, + HEAPF32, + value >> 2, + count * 16, + ); + return; + } + if (count <= 18) { + var view = miniTempWebGLFloatBuffers[16 * count - 1]; + var heap = HEAPF32; + value >>= 2; + for (var i = 0; i < 16 * count; i += 16) { + var dst = value + i; + view[i] = heap[dst]; + view[i + 1] = heap[dst + 1]; + view[i + 2] = heap[dst + 2]; + view[i + 3] = heap[dst + 3]; + view[i + 4] = heap[dst + 4]; + view[i + 5] = heap[dst + 5]; + view[i + 6] = heap[dst + 6]; + view[i + 7] = heap[dst + 7]; + view[i + 8] = heap[dst + 8]; + view[i + 9] = heap[dst + 9]; + view[i + 10] = heap[dst + 10]; + view[i + 11] = heap[dst + 11]; + view[i + 12] = heap[dst + 12]; + view[i + 13] = heap[dst + 13]; + view[i + 14] = heap[dst + 14]; + view[i + 15] = heap[dst + 15]; + } + } else { + var view = HEAPF32.subarray(value >> 2, (value + count * 64) >> 2); + } + GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view); + } + function _glUseProgram(program) { + program = GL.programs[program]; + GLctx.useProgram(program); + GLctx.currentProgram = program; + } + function _glVertexAttribPointer(index, size, type, normalized, stride, ptr) { + var cb = GL.currentContext.clientBuffers[index]; + if (!GLctx.currentArrayBufferBinding) { + cb.size = size; + cb.type = type; + cb.normalized = normalized; + cb.stride = stride; + cb.ptr = ptr; + cb.clientside = true; + cb.vertexAttribPointerAdaptor = function (index, size, type, normalized, stride, ptr) { + this.vertexAttribPointer(index, size, type, normalized, stride, ptr); + }; + return; + } + cb.clientside = false; + GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr); + } + function _glViewport(x0, x1, x2, x3) { + GLctx["viewport"](x0, x1, x2, x3); + } + function _mediapipe_find_canvas_event_target(canvasSelector) { + return Emval.toHandle(findCanvasEventTarget(canvasSelector)); + } + function _mediapipe_webgl_tex_image_drawable(drawableHandle) { + const drawable = Emval.toValue(drawableHandle); + GLctx.texImage2D(GLctx.TEXTURE_2D, 0, GLctx.RGBA, GLctx.RGBA, GLctx.UNSIGNED_BYTE, drawable); + } + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) {} + return sum; + } + var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + if (days > daysInCurrentMonth - newDate.getDate()) { + days -= daysInCurrentMonth - newDate.getDate() + 1; + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth + 1); + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear() + 1); + } + } else { + newDate.setDate(newDate.getDate() + days); + return newDate; + } + } + return newDate; + } + function writeArrayToMemory(array, buffer) { + assert( + array.length >= 0, + "writeArrayToMemory array must have a length (should be an array or typed array)", + ); + HEAP8.set(array, buffer); + } + function _strftime(s, maxsize, format, tm) { + var tm_zone = HEAP32[(tm + 40) >> 2]; + var date = { + tm_sec: HEAP32[tm >> 2], + tm_min: HEAP32[(tm + 4) >> 2], + tm_hour: HEAP32[(tm + 8) >> 2], + tm_mday: HEAP32[(tm + 12) >> 2], + tm_mon: HEAP32[(tm + 16) >> 2], + tm_year: HEAP32[(tm + 20) >> 2], + tm_wday: HEAP32[(tm + 24) >> 2], + tm_yday: HEAP32[(tm + 28) >> 2], + tm_isdst: HEAP32[(tm + 32) >> 2], + tm_gmtoff: HEAP32[(tm + 36) >> 2], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : "", + }; + var pattern = UTF8ToString(format); + var EXPANSION_RULES_1 = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y", + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]); + } + var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]; + var MONTHS = [ + "January", + "February", + "March", + "April", + "May", + "June", + "July", + "August", + "September", + "October", + "November", + "December", + ]; + function leadingSomething(value, digits, character) { + var str = typeof value == "number" ? value.toString() : value || ""; + while (str.length < digits) { + str = character[0] + str; + } + return str; + } + function leadingNulls(value, digits) { + return leadingSomething(value, digits, "0"); + } + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : value > 0 ? 1 : 0; + } + var compare; + if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) { + compare = sgn(date1.getDate() - date2.getDate()); + } + } + return compare; + } + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: + return new Date(janFourth.getFullYear() - 1, 11, 29); + case 1: + return janFourth; + case 2: + return new Date(janFourth.getFullYear(), 0, 3); + case 3: + return new Date(janFourth.getFullYear(), 0, 2); + case 4: + return new Date(janFourth.getFullYear(), 0, 1); + case 5: + return new Date(janFourth.getFullYear() - 1, 11, 31); + case 6: + return new Date(janFourth.getFullYear() - 1, 11, 30); + } + } + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday); + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4); + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear() + 1; + } + return thisDate.getFullYear(); + } + return thisDate.getFullYear() - 1; + } + var EXPANSION_RULES_2 = { + "%a": function (date) { + return WEEKDAYS[date.tm_wday].substring(0, 3); + }, + "%A": function (date) { + return WEEKDAYS[date.tm_wday]; + }, + "%b": function (date) { + return MONTHS[date.tm_mon].substring(0, 3); + }, + "%B": function (date) { + return MONTHS[date.tm_mon]; + }, + "%C": function (date) { + var year = date.tm_year + 1900; + return leadingNulls((year / 100) | 0, 2); + }, + "%d": function (date) { + return leadingNulls(date.tm_mday, 2); + }, + "%e": function (date) { + return leadingSomething(date.tm_mday, 2, " "); + }, + "%g": function (date) { + return getWeekBasedYear(date).toString().substring(2); + }, + "%G": function (date) { + return getWeekBasedYear(date); + }, + "%H": function (date) { + return leadingNulls(date.tm_hour, 2); + }, + "%I": function (date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + "%j": function (date) { + return leadingNulls( + date.tm_mday + + __arraySum( + __isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, + date.tm_mon - 1, + ), + 3, + ); + }, + "%m": function (date) { + return leadingNulls(date.tm_mon + 1, 2); + }, + "%M": function (date) { + return leadingNulls(date.tm_min, 2); + }, + "%n": function () { + return "\n"; + }, + "%p": function (date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return "AM"; + } + return "PM"; + }, + "%S": function (date) { + return leadingNulls(date.tm_sec, 2); + }, + "%t": function () { + return "\t"; + }, + "%u": function (date) { + return date.tm_wday || 7; + }, + "%U": function (date) { + var days = date.tm_yday + 7 - date.tm_wday; + return leadingNulls(Math.floor(days / 7), 2); + }, + "%V": function (date) { + var val = Math.floor((date.tm_yday + 7 - ((date.tm_wday + 6) % 7)) / 7); + if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) { + val++; + } + if (!val) { + val = 52; + var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7; + if (dec31 == 4 || (dec31 == 5 && __isLeapYear((date.tm_year % 400) - 1))) { + val++; + } + } else if (val == 53) { + var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7; + if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year))) val = 1; + } + return leadingNulls(val, 2); + }, + "%w": function (date) { + return date.tm_wday; + }, + "%W": function (date) { + var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7); + return leadingNulls(Math.floor(days / 7), 2); + }, + "%y": function (date) { + return (date.tm_year + 1900).toString().substring(2); + }, + "%Y": function (date) { + return date.tm_year + 1900; + }, + "%z": function (date) { + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + off = (off / 60) * 100 + (off % 60); + return (ahead ? "+" : "-") + String("0000" + off).slice(-4); + }, + "%Z": function (date) { + return date.tm_zone; + }, + "%%": function () { + return "%"; + }, + }; + pattern = pattern.replace(/%%/g, "\0\0"); + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date)); + } + } + pattern = pattern.replace(/\0\0/g, "%"); + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + writeArrayToMemory(bytes, s); + return bytes.length - 1; + } + function _strftime_l(s, maxsize, format, tm, loc) { + return _strftime(s, maxsize, format, tm); + } + function _wgpuBindGroupLayoutRelease(id) { + WebGPU.mgrBindGroupLayout.release(id); + } + function _wgpuBindGroupRelease(id) { + WebGPU.mgrBindGroup.release(id); + } + function _wgpuBufferGetMappedRange(bufferId, offset, size) { + var bufferWrapper = WebGPU.mgrBuffer.objects[bufferId]; + assert(typeof bufferWrapper != "undefined"); + if (size === 0) warnOnce("getMappedRange size=0 no longer means WGPU_WHOLE_MAP_SIZE"); + size = size >>> 0; + if (size === 4294967295) size = undefined; + if (bufferWrapper.mapMode !== 2) { + abort("GetMappedRange called, but buffer not mapped for writing"); + return 0; + } + var mapped; + try { + mapped = bufferWrapper.object["getMappedRange"](offset, size); + } catch (ex) { + err("wgpuBufferGetMappedRange(" + offset + ", " + size + ") failed: " + ex); + return 0; + } + var data = _malloc(mapped.byteLength); + HEAPU8.fill(0, data, mapped.byteLength); + bufferWrapper.onUnmap.push(function () { + new Uint8Array(mapped).set(HEAPU8.subarray(data, data + mapped.byteLength)); + _free(data); + }); + return data; + } + function _wgpuBufferReference(id) { + WebGPU.mgrBuffer.reference(id); + } + function _wgpuBufferRelease(id) { + WebGPU.mgrBuffer.release(id); + } + function _wgpuBufferUnmap(bufferId) { + var bufferWrapper = WebGPU.mgrBuffer.objects[bufferId]; + assert(typeof bufferWrapper != "undefined"); + if (!bufferWrapper.onUnmap) { + return; + } + for (var i = 0; i < bufferWrapper.onUnmap.length; ++i) { + bufferWrapper.onUnmap[i](); + } + bufferWrapper.onUnmap = undefined; + bufferWrapper.object["unmap"](); + } + function _wgpuCommandBufferRelease(id) { + WebGPU.mgrCommandBuffer.release(id); + } + function _wgpuCommandEncoderBeginComputePass(encoderId, descriptor) { + var desc; + function makeComputePassTimestampWrite(twPtr) { + return { + querySet: WebGPU.mgrQuerySet.get(HEAPU32[twPtr >> 2]), + queryIndex: HEAPU32[(twPtr + 4) >> 2], + location: WebGPU.ComputePassTimestampLocation[HEAPU32[(twPtr + 8) >> 2]], + }; + } + function makeComputePassTimestampWrites(count, twPtr) { + var timestampWrites = []; + for (var i = 0; i < count; ++i) { + timestampWrites.push(makeComputePassTimestampWrite(twPtr + 12 * i)); + } + return timestampWrites; + } + if (descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + desc = {}; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var timestampWriteCount = HEAPU32[(descriptor + 8) >> 2]; + if (timestampWriteCount) { + desc["timestampWrites"] = makeComputePassTimestampWrites( + timestampWriteCount, + HEAPU32[(descriptor + 12) >> 2], + ); + } + } + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + return WebGPU.mgrComputePassEncoder.create(commandEncoder["beginComputePass"](desc)); + } + function _wgpuCommandEncoderBeginRenderPass(encoderId, descriptor) { + assert(descriptor); + function makeColorAttachment(caPtr) { + var viewPtr = HEAPU32[caPtr >> 2]; + if (viewPtr === 0) { + return undefined; + } + var loadOpInt = HEAPU32[(caPtr + 8) >> 2]; + assert(loadOpInt !== 0); + var storeOpInt = HEAPU32[(caPtr + 12) >> 2]; + assert(storeOpInt !== 0); + var clearValue = WebGPU.makeColor(caPtr + 16); + return { + view: WebGPU.mgrTextureView.get(viewPtr), + resolveTarget: WebGPU.mgrTextureView.get(HEAPU32[(caPtr + 4) >> 2]), + clearValue: clearValue, + loadOp: WebGPU.LoadOp[loadOpInt], + storeOp: WebGPU.StoreOp[storeOpInt], + }; + } + function makeColorAttachments(count, caPtr) { + var attachments = []; + for (var i = 0; i < count; ++i) { + attachments.push(makeColorAttachment(caPtr + 48 * i)); + } + return attachments; + } + function makeDepthStencilAttachment(dsaPtr) { + if (dsaPtr === 0) return undefined; + return { + view: WebGPU.mgrTextureView.get(HEAPU32[dsaPtr >> 2]), + depthClearValue: HEAPF32[(dsaPtr + 12) >> 2], + depthLoadOp: WebGPU.LoadOp[HEAPU32[(dsaPtr + 4) >> 2]], + depthStoreOp: WebGPU.StoreOp[HEAPU32[(dsaPtr + 8) >> 2]], + depthReadOnly: HEAP8[(dsaPtr + 16) >> 0] !== 0, + stencilClearValue: HEAPU32[(dsaPtr + 28) >> 2], + stencilLoadOp: WebGPU.LoadOp[HEAPU32[(dsaPtr + 20) >> 2]], + stencilStoreOp: WebGPU.StoreOp[HEAPU32[(dsaPtr + 24) >> 2]], + stencilReadOnly: HEAP8[(dsaPtr + 32) >> 0] !== 0, + }; + } + function makeRenderPassTimestampWrite(twPtr) { + return { + querySet: WebGPU.mgrQuerySet.get(HEAPU32[twPtr >> 2]), + queryIndex: HEAPU32[(twPtr + 4) >> 2], + location: WebGPU.RenderPassTimestampLocation[HEAPU32[(twPtr + 8) >> 2]], + }; + } + function makeRenderPassTimestampWrites(count, twPtr) { + var timestampWrites = []; + for (var i = 0; i < count; ++i) { + timestampWrites.push(makeRenderPassTimestampWrite(twPtr + 12 * i)); + } + return timestampWrites; + } + function makeRenderPassDescriptor(descriptor) { + assert(descriptor); + var nextInChainPtr = HEAPU32[descriptor >> 2]; + var maxDrawCount = undefined; + if (nextInChainPtr !== 0) { + var sType = HEAPU32[(nextInChainPtr + 4) >> 2]; + assert(sType === 15); + assert(0 === HEAPU32[nextInChainPtr >> 2]); + var renderPassDescriptorMaxDrawCount = nextInChainPtr; + assert(renderPassDescriptorMaxDrawCount); + assert(HEAPU32[renderPassDescriptorMaxDrawCount >> 2] === 0); + maxDrawCount = + HEAPU32[(renderPassDescriptorMaxDrawCount + 4 + 8) >> 2] * 4294967296 + + HEAPU32[(renderPassDescriptorMaxDrawCount + 8) >> 2]; + } + var desc = { + label: undefined, + colorAttachments: makeColorAttachments( + HEAPU32[(descriptor + 8) >> 2], + HEAPU32[(descriptor + 12) >> 2], + ), + depthStencilAttachment: makeDepthStencilAttachment(HEAPU32[(descriptor + 16) >> 2]), + occlusionQuerySet: WebGPU.mgrQuerySet.get(HEAPU32[(descriptor + 20) >> 2]), + maxDrawCount: maxDrawCount, + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var timestampWriteCount = HEAPU32[(descriptor + 24) >> 2]; + if (timestampWriteCount) { + desc["timestampWrites"] = makeRenderPassTimestampWrites( + timestampWriteCount, + HEAPU32[(descriptor + 28) >> 2], + ); + } + return desc; + } + var desc = makeRenderPassDescriptor(descriptor); + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + return WebGPU.mgrRenderPassEncoder.create(commandEncoder["beginRenderPass"](desc)); + } + function _wgpuCommandEncoderCopyBufferToTexture(encoderId, srcPtr, dstPtr, copySizePtr) { + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + var copySize = WebGPU.makeExtent3D(copySizePtr); + commandEncoder["copyBufferToTexture"]( + WebGPU.makeImageCopyBuffer(srcPtr), + WebGPU.makeImageCopyTexture(dstPtr), + copySize, + ); + } + function _wgpuCommandEncoderCopyTextureToTexture(encoderId, srcPtr, dstPtr, copySizePtr) { + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + var copySize = WebGPU.makeExtent3D(copySizePtr); + commandEncoder["copyTextureToTexture"]( + WebGPU.makeImageCopyTexture(srcPtr), + WebGPU.makeImageCopyTexture(dstPtr), + copySize, + ); + } + function _wgpuCommandEncoderFinish(encoderId) { + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + return WebGPU.mgrCommandBuffer.create(commandEncoder["finish"]()); + } + function _wgpuCommandEncoderRelease(id) { + WebGPU.mgrCommandEncoder.release(id); + } + function _wgpuComputePassEncoderDispatchWorkgroups(passId, x, y, z) { + var pass = WebGPU.mgrComputePassEncoder.get(passId); + if (pass["dispatchWorkgroups"]) { + pass["dispatchWorkgroups"](x, y, z); + } else { + pass["dispatch"](x, y, z); + } + } + function _wgpuComputePassEncoderEnd(passId) { + var pass = WebGPU.mgrComputePassEncoder.get(passId); + pass["end"](); + } + function _wgpuComputePassEncoderRelease(id) { + WebGPU.mgrComputePassEncoder.release(id); + } + function _wgpuComputePassEncoderSetBindGroup( + passId, + groupIndex, + groupId, + dynamicOffsetCount, + dynamicOffsetsPtr, + ) { + var pass = WebGPU.mgrComputePassEncoder.get(passId); + var group = WebGPU.mgrBindGroup.get(groupId); + if (dynamicOffsetCount == 0) { + pass["setBindGroup"](groupIndex, group); + } else { + var offsets = []; + for (var i = 0; i < dynamicOffsetCount; i++, dynamicOffsetsPtr += 4) { + offsets.push(HEAPU32[dynamicOffsetsPtr >> 2]); + } + pass["setBindGroup"](groupIndex, group, offsets); + } + } + function _wgpuComputePassEncoderSetPipeline(passId, pipelineId) { + var pass = WebGPU.mgrComputePassEncoder.get(passId); + var pipeline = WebGPU.mgrComputePipeline.get(pipelineId); + pass["setPipeline"](pipeline); + } + function _wgpuComputePipelineGetBindGroupLayout(pipelineId, groupIndex) { + var pipeline = WebGPU.mgrComputePipeline.get(pipelineId); + return WebGPU.mgrBindGroupLayout.create(pipeline["getBindGroupLayout"](groupIndex)); + } + function _wgpuComputePipelineRelease(id) { + WebGPU.mgrComputePipeline.release(id); + } + function _wgpuDeviceCreateBindGroup(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + function makeEntry(entryPtr) { + assert(entryPtr); + var bufferId = HEAPU32[(entryPtr + 8) >> 2]; + var samplerId = HEAPU32[(entryPtr + 32) >> 2]; + var textureViewId = HEAPU32[(entryPtr + 36) >> 2]; + assert((bufferId !== 0) + (samplerId !== 0) + (textureViewId !== 0) === 1); + var binding = HEAPU32[(entryPtr + 4) >> 2]; + if (bufferId) { + var size_low = HEAPU32[(entryPtr + 24) >> 2]; + var size_high = HEAPU32[(entryPtr + 28) >> 2]; + var size = + size_high === -1 && size_low === -1 + ? undefined + : (assert(size_high < 2097152), size_high * 4294967296 + size_low); + return { + binding: binding, + resource: { + buffer: WebGPU.mgrBuffer.get(bufferId), + offset: + HEAPU32[(entryPtr + 4 + 16) >> 2] * 4294967296 + HEAPU32[(entryPtr + 16) >> 2], + size: size, + }, + }; + } else if (samplerId) { + return { binding: binding, resource: WebGPU.mgrSampler.get(samplerId) }; + } else { + return { binding: binding, resource: WebGPU.mgrTextureView.get(textureViewId) }; + } + } + function makeEntries(count, entriesPtrs) { + var entries = []; + for (var i = 0; i < count; ++i) { + entries.push(makeEntry(entriesPtrs + 40 * i)); + } + return entries; + } + var desc = { + label: undefined, + layout: WebGPU.mgrBindGroupLayout.get(HEAPU32[(descriptor + 8) >> 2]), + entries: makeEntries(HEAPU32[(descriptor + 12) >> 2], HEAPU32[(descriptor + 16) >> 2]), + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrBindGroup.create(device["createBindGroup"](desc)); + } + function _wgpuDeviceCreateBuffer(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var mappedAtCreation = HEAP8[(descriptor + 24) >> 0] !== 0; + var desc = { + label: undefined, + usage: HEAPU32[(descriptor + 8) >> 2], + size: HEAPU32[(descriptor + 4 + 16) >> 2] * 4294967296 + HEAPU32[(descriptor + 16) >> 2], + mappedAtCreation: mappedAtCreation, + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + var bufferWrapper = {}; + var id = WebGPU.mgrBuffer.create(device["createBuffer"](desc), bufferWrapper); + if (mappedAtCreation) { + bufferWrapper.mapMode = 2; + bufferWrapper.onUnmap = []; + } + return id; + } + function _wgpuDeviceCreateCommandEncoder(deviceId, descriptor) { + var desc; + if (descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + desc = { label: undefined }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + } + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrCommandEncoder.create(device["createCommandEncoder"](desc)); + } + function _wgpuDeviceCreateComputePipeline(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var desc = { + label: undefined, + layout: WebGPU.mgrPipelineLayout.get(HEAPU32[(descriptor + 8) >> 2]), + compute: WebGPU.makeProgrammableStageDescriptor(descriptor + 12), + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrComputePipeline.create(device["createComputePipeline"](desc)); + } + function _wgpuDeviceCreateRenderPipeline(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + function makePrimitiveState(rsPtr) { + if (!rsPtr) return undefined; + assert(rsPtr); + assert(HEAPU32[rsPtr >> 2] === 0); + return { + topology: WebGPU.PrimitiveTopology[HEAPU32[(rsPtr + 4) >> 2]], + stripIndexFormat: WebGPU.IndexFormat[HEAPU32[(rsPtr + 8) >> 2]], + frontFace: WebGPU.FrontFace[HEAPU32[(rsPtr + 12) >> 2]], + cullMode: WebGPU.CullMode[HEAPU32[(rsPtr + 16) >> 2]], + }; + } + function makeBlendComponent(bdPtr) { + if (!bdPtr) return undefined; + return { + operation: WebGPU.BlendOperation[HEAPU32[bdPtr >> 2]], + srcFactor: WebGPU.BlendFactor[HEAPU32[(bdPtr + 4) >> 2]], + dstFactor: WebGPU.BlendFactor[HEAPU32[(bdPtr + 8) >> 2]], + }; + } + function makeBlendState(bsPtr) { + if (!bsPtr) return undefined; + assert(bsPtr); + assert(HEAPU32[bsPtr >> 2] === 0); + return { alpha: makeBlendComponent(bsPtr + 12), color: makeBlendComponent(bsPtr + 0) }; + } + function makeColorState(csPtr) { + assert(csPtr); + assert(HEAPU32[csPtr >> 2] === 0); + var formatInt = HEAPU32[(csPtr + 4) >> 2]; + return formatInt === 0 + ? undefined + : { + format: WebGPU.TextureFormat[formatInt], + blend: makeBlendState(HEAPU32[(csPtr + 8) >> 2]), + writeMask: HEAPU32[(csPtr + 12) >> 2], + }; + } + function makeColorStates(count, csArrayPtr) { + var states = []; + for (var i = 0; i < count; ++i) { + states.push(makeColorState(csArrayPtr + 16 * i)); + } + return states; + } + function makeStencilStateFace(ssfPtr) { + assert(ssfPtr); + return { + compare: WebGPU.CompareFunction[HEAPU32[ssfPtr >> 2]], + failOp: WebGPU.StencilOperation[HEAPU32[(ssfPtr + 4) >> 2]], + depthFailOp: WebGPU.StencilOperation[HEAPU32[(ssfPtr + 8) >> 2]], + passOp: WebGPU.StencilOperation[HEAPU32[(ssfPtr + 12) >> 2]], + }; + } + function makeDepthStencilState(dssPtr) { + if (!dssPtr) return undefined; + assert(dssPtr); + return { + format: WebGPU.TextureFormat[HEAPU32[(dssPtr + 4) >> 2]], + depthWriteEnabled: HEAP8[(dssPtr + 8) >> 0] !== 0, + depthCompare: WebGPU.CompareFunction[HEAPU32[(dssPtr + 12) >> 2]], + stencilFront: makeStencilStateFace(dssPtr + 16), + stencilBack: makeStencilStateFace(dssPtr + 32), + stencilReadMask: HEAPU32[(dssPtr + 48) >> 2], + stencilWriteMask: HEAPU32[(dssPtr + 52) >> 2], + depthBias: HEAPU32[(dssPtr + 56) >> 2], + depthBiasSlopeScale: HEAPF32[(dssPtr + 60) >> 2], + depthBiasClamp: HEAPF32[(dssPtr + 64) >> 2], + }; + } + function makeVertexAttribute(vaPtr) { + assert(vaPtr); + return { + format: WebGPU.VertexFormat[HEAPU32[vaPtr >> 2]], + offset: HEAPU32[(vaPtr + 4 + 8) >> 2] * 4294967296 + HEAPU32[(vaPtr + 8) >> 2], + shaderLocation: HEAPU32[(vaPtr + 16) >> 2], + }; + } + function makeVertexAttributes(count, vaArrayPtr) { + var vas = []; + for (var i = 0; i < count; ++i) { + vas.push(makeVertexAttribute(vaArrayPtr + i * 24)); + } + return vas; + } + function makeVertexBuffer(vbPtr) { + if (!vbPtr) return undefined; + var stepModeInt = HEAPU32[(vbPtr + 8) >> 2]; + return stepModeInt === 2 + ? null + : { + arrayStride: HEAPU32[(vbPtr + 4) >> 2] * 4294967296 + HEAPU32[vbPtr >> 2], + stepMode: WebGPU.VertexStepMode[stepModeInt], + attributes: makeVertexAttributes( + HEAPU32[(vbPtr + 12) >> 2], + HEAPU32[(vbPtr + 16) >> 2], + ), + }; + } + function makeVertexBuffers(count, vbArrayPtr) { + if (!count) return undefined; + var vbs = []; + for (var i = 0; i < count; ++i) { + vbs.push(makeVertexBuffer(vbArrayPtr + i * 24)); + } + return vbs; + } + function makeVertexState(viPtr) { + if (!viPtr) return undefined; + assert(viPtr); + assert(HEAPU32[viPtr >> 2] === 0); + return { + module: WebGPU.mgrShaderModule.get(HEAPU32[(viPtr + 4) >> 2]), + entryPoint: UTF8ToString(HEAPU32[(viPtr + 8) >> 2]), + constants: WebGPU.makePipelineConstants( + HEAPU32[(viPtr + 12) >> 2], + HEAPU32[(viPtr + 16) >> 2], + ), + buffers: makeVertexBuffers(HEAPU32[(viPtr + 20) >> 2], HEAPU32[(viPtr + 24) >> 2]), + }; + } + function makeMultisampleState(msPtr) { + if (!msPtr) return undefined; + assert(msPtr); + assert(HEAPU32[msPtr >> 2] === 0); + return { + count: HEAPU32[(msPtr + 4) >> 2], + mask: HEAPU32[(msPtr + 8) >> 2], + alphaToCoverageEnabled: HEAP8[(msPtr + 12) >> 0] !== 0, + }; + } + function makeFragmentState(fsPtr) { + if (!fsPtr) return undefined; + assert(fsPtr); + assert(HEAPU32[fsPtr >> 2] === 0); + return { + module: WebGPU.mgrShaderModule.get(HEAPU32[(fsPtr + 4) >> 2]), + entryPoint: UTF8ToString(HEAPU32[(fsPtr + 8) >> 2]), + constants: WebGPU.makePipelineConstants( + HEAPU32[(fsPtr + 12) >> 2], + HEAPU32[(fsPtr + 16) >> 2], + ), + targets: makeColorStates(HEAPU32[(fsPtr + 20) >> 2], HEAPU32[(fsPtr + 24) >> 2]), + }; + } + var desc = { + label: undefined, + layout: WebGPU.mgrPipelineLayout.get(HEAPU32[(descriptor + 8) >> 2]), + vertex: makeVertexState(descriptor + 12), + primitive: makePrimitiveState(descriptor + 40), + depthStencil: makeDepthStencilState(HEAPU32[(descriptor + 60) >> 2]), + multisample: makeMultisampleState(descriptor + 64), + fragment: makeFragmentState(HEAPU32[(descriptor + 80) >> 2]), + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrRenderPipeline.create(device["createRenderPipeline"](desc)); + } + function _wgpuDeviceCreateSampler(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var desc = { + label: undefined, + addressModeU: WebGPU.AddressMode[HEAPU32[(descriptor + 8) >> 2]], + addressModeV: WebGPU.AddressMode[HEAPU32[(descriptor + 12) >> 2]], + addressModeW: WebGPU.AddressMode[HEAPU32[(descriptor + 16) >> 2]], + magFilter: WebGPU.FilterMode[HEAPU32[(descriptor + 20) >> 2]], + minFilter: WebGPU.FilterMode[HEAPU32[(descriptor + 24) >> 2]], + mipmapFilter: WebGPU.FilterMode[HEAPU32[(descriptor + 28) >> 2]], + lodMinClamp: HEAPF32[(descriptor + 32) >> 2], + lodMaxClamp: HEAPF32[(descriptor + 36) >> 2], + compare: WebGPU.CompareFunction[HEAPU32[(descriptor + 40) >> 2]], + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrSampler.create(device["createSampler"](desc)); + } + function _wgpuDeviceCreateShaderModule(deviceId, descriptor) { + assert(descriptor); + var nextInChainPtr = HEAPU32[descriptor >> 2]; + assert(nextInChainPtr !== 0); + var sType = HEAPU32[(nextInChainPtr + 4) >> 2]; + var desc = { label: undefined, code: "" }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + switch (sType) { + case 5: { + var count = HEAPU32[(nextInChainPtr + 8) >> 2]; + var start = HEAPU32[(nextInChainPtr + 12) >> 2]; + desc["code"] = HEAPU32.subarray(start >> 2, (start >> 2) + count); + break; + } + case 6: { + var sourcePtr = HEAPU32[(nextInChainPtr + 8) >> 2]; + if (sourcePtr) { + desc["code"] = UTF8ToString(sourcePtr); + } + break; + } + default: + abort("unrecognized ShaderModule sType"); + } + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrShaderModule.create(device["createShaderModule"](desc)); + } + function _wgpuDeviceCreateTexture(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var desc = { + label: undefined, + size: WebGPU.makeExtent3D(descriptor + 16), + mipLevelCount: HEAPU32[(descriptor + 32) >> 2], + sampleCount: HEAPU32[(descriptor + 36) >> 2], + dimension: WebGPU.TextureDimension[HEAPU32[(descriptor + 12) >> 2]], + format: WebGPU.TextureFormat[HEAPU32[(descriptor + 28) >> 2]], + usage: HEAPU32[(descriptor + 8) >> 2], + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var viewFormatCount = HEAPU32[(descriptor + 40) >> 2]; + if (viewFormatCount) { + var viewFormatsPtr = HEAPU32[(descriptor + 44) >> 2]; + desc["viewFormats"] = Array.from( + HEAP32.subarray(viewFormatsPtr >> 2, (viewFormatsPtr >> 2) + viewFormatCount), + function (format) { + return WebGPU.TextureFormat[format]; + }, + ); + } + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrTexture.create(device["createTexture"](desc)); + } + function _wgpuDeviceGetQueue(deviceId) { + var queueId = WebGPU.mgrDevice.objects[deviceId].queueId; + assert(queueId, "wgpuDeviceGetQueue: queue was missing or null"); + WebGPU.mgrQueue.reference(queueId); + return queueId; + } + function _wgpuDeviceReference(id) { + WebGPU.mgrDevice.reference(id); + } + function _wgpuDeviceRelease(id) { + WebGPU.mgrDevice.release(id); + } + function _wgpuPipelineLayoutRelease(id) { + WebGPU.mgrPipelineLayout.release(id); + } + function _wgpuQuerySetRelease(id) { + WebGPU.mgrQuerySet.release(id); + } + function _wgpuQueueRelease(id) { + WebGPU.mgrQueue.release(id); + } + function _wgpuQueueSubmit(queueId, commandCount, commands) { + assert(commands % 4 === 0); + var queue = WebGPU.mgrQueue.get(queueId); + var cmds = Array.from( + HEAP32.subarray(commands >> 2, (commands >> 2) + commandCount), + function (id) { + return WebGPU.mgrCommandBuffer.get(id); + }, + ); + queue["submit"](cmds); + } + function _wgpuQueueWriteBuffer( + queueId, + bufferId, + bufferOffset_low, + bufferOffset_high, + data, + size, + ) { + var queue = WebGPU.mgrQueue.get(queueId); + var buffer = WebGPU.mgrBuffer.get(bufferId); + var bufferOffset = + (assert(bufferOffset_high < 2097152), bufferOffset_high * 4294967296 + bufferOffset_low); + var subarray = HEAPU8.subarray(data, data + size); + queue["writeBuffer"](buffer, bufferOffset, subarray, 0, size); + } + function _wgpuRenderPassEncoderDraw( + passId, + vertexCount, + instanceCount, + firstVertex, + firstInstance, + ) { + var pass = WebGPU.mgrRenderPassEncoder.get(passId); + pass["draw"](vertexCount, instanceCount, firstVertex, firstInstance); + } + function _wgpuRenderPassEncoderEnd(passId) { + var pass = WebGPU.mgrRenderPassEncoder.get(passId); + pass["end"](); + } + function _wgpuRenderPassEncoderRelease(id) { + WebGPU.mgrRenderPassEncoder.release(id); + } + function _wgpuRenderPassEncoderSetBindGroup( + passId, + groupIndex, + groupId, + dynamicOffsetCount, + dynamicOffsetsPtr, + ) { + var pass = WebGPU.mgrRenderPassEncoder.get(passId); + var group = WebGPU.mgrBindGroup.get(groupId); + if (dynamicOffsetCount == 0) { + pass["setBindGroup"](groupIndex, group); + } else { + var offsets = []; + for (var i = 0; i < dynamicOffsetCount; i++, dynamicOffsetsPtr += 4) { + offsets.push(HEAPU32[dynamicOffsetsPtr >> 2]); + } + pass["setBindGroup"](groupIndex, group, offsets); + } + } + function _wgpuRenderPassEncoderSetPipeline(passId, pipelineId) { + var pass = WebGPU.mgrRenderPassEncoder.get(passId); + var pipeline = WebGPU.mgrRenderPipeline.get(pipelineId); + pass["setPipeline"](pipeline); + } + function _wgpuRenderPipelineGetBindGroupLayout(pipelineId, groupIndex) { + var pipeline = WebGPU.mgrRenderPipeline.get(pipelineId); + return WebGPU.mgrBindGroupLayout.create(pipeline["getBindGroupLayout"](groupIndex)); + } + function _wgpuRenderPipelineRelease(id) { + WebGPU.mgrRenderPipeline.release(id); + } + function _wgpuSamplerReference(id) { + WebGPU.mgrSampler.reference(id); + } + function _wgpuSamplerRelease(id) { + WebGPU.mgrSampler.release(id); + } + function _wgpuShaderModuleReference(id) { + WebGPU.mgrShaderModule.reference(id); + } + function _wgpuShaderModuleRelease(id) { + WebGPU.mgrShaderModule.release(id); + } + function _wgpuTextureCreateView(textureId, descriptor) { + var desc; + if (descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var mipLevelCount = HEAPU32[(descriptor + 20) >> 2]; + var arrayLayerCount = HEAPU32[(descriptor + 28) >> 2]; + desc = { + format: WebGPU.TextureFormat[HEAPU32[(descriptor + 8) >> 2]], + dimension: WebGPU.TextureViewDimension[HEAPU32[(descriptor + 12) >> 2]], + baseMipLevel: HEAPU32[(descriptor + 16) >> 2], + mipLevelCount: mipLevelCount === 4294967295 ? undefined : mipLevelCount, + baseArrayLayer: HEAPU32[(descriptor + 24) >> 2], + arrayLayerCount: arrayLayerCount === 4294967295 ? undefined : arrayLayerCount, + aspect: WebGPU.TextureAspect[HEAPU32[(descriptor + 32) >> 2]], + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + } + var texture = WebGPU.mgrTexture.get(textureId); + return WebGPU.mgrTextureView.create(texture["createView"](desc)); + } + function _wgpuTextureDestroy(textureId) { + WebGPU.mgrTexture.get(textureId)["destroy"](); + } + function _wgpuTextureReference(id) { + WebGPU.mgrTexture.reference(id); + } + function _wgpuTextureRelease(id) { + WebGPU.mgrTexture.release(id); + } + function _wgpuTextureViewReference(id) { + WebGPU.mgrTextureView.reference(id); + } + function _wgpuTextureViewRelease(id) { + WebGPU.mgrTextureView.release(id); + } + Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas) { + Browser.requestFullscreen(lockPointer, resizeCanvas); + }; + Module["requestFullScreen"] = function Module_requestFullScreen() { + Browser.requestFullScreen(); + }; + Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { + Browser.requestAnimationFrame(func); + }; + Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { + Browser.setCanvasSize(width, height, noUpdates); + }; + Module["pauseMainLoop"] = function Module_pauseMainLoop() { + Browser.mainLoop.pause(); + }; + Module["resumeMainLoop"] = function Module_resumeMainLoop() { + Browser.mainLoop.resume(); + }; + Module["getUserMedia"] = function Module_getUserMedia() { + Browser.getUserMedia(); + }; + Module["createContext"] = function Module_createContext( + canvas, + useWebGL, + setInModule, + webGLContextAttributes, + ) { + return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes); + }; + var preloadedImages = {}; + var preloadedAudios = {}; + var FSNode = function (parent, name, mode, rdev) { + if (!parent) { + parent = this; + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + }; + var readMode = 292 | 73; + var writeMode = 146; + Object.defineProperties(FSNode.prototype, { + read: { + get: function () { + return (this.mode & readMode) === readMode; + }, + set: function (val) { + val ? (this.mode |= readMode) : (this.mode &= ~readMode); + }, + }, + write: { + get: function () { + return (this.mode & writeMode) === writeMode; + }, + set: function (val) { + val ? (this.mode |= writeMode) : (this.mode &= ~writeMode); + }, + }, + isFolder: { + get: function () { + return FS.isDir(this.mode); + }, + }, + isDevice: { + get: function () { + return FS.isChrdev(this.mode); + }, + }, + }); + FS.FSNode = FSNode; + FS.staticInit(); + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_unlink"] = FS.unlink; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createDevice"] = FS.createDevice; + ERRNO_CODES = { + EPERM: 63, + ENOENT: 44, + ESRCH: 71, + EINTR: 27, + EIO: 29, + ENXIO: 60, + E2BIG: 1, + ENOEXEC: 45, + EBADF: 8, + ECHILD: 12, + EAGAIN: 6, + EWOULDBLOCK: 6, + ENOMEM: 48, + EACCES: 2, + EFAULT: 21, + ENOTBLK: 105, + EBUSY: 10, + EEXIST: 20, + EXDEV: 75, + ENODEV: 43, + ENOTDIR: 54, + EISDIR: 31, + EINVAL: 28, + ENFILE: 41, + EMFILE: 33, + ENOTTY: 59, + ETXTBSY: 74, + EFBIG: 22, + ENOSPC: 51, + ESPIPE: 70, + EROFS: 69, + EMLINK: 34, + EPIPE: 64, + EDOM: 18, + ERANGE: 68, + ENOMSG: 49, + EIDRM: 24, + ECHRNG: 106, + EL2NSYNC: 156, + EL3HLT: 107, + EL3RST: 108, + ELNRNG: 109, + EUNATCH: 110, + ENOCSI: 111, + EL2HLT: 112, + EDEADLK: 16, + ENOLCK: 46, + EBADE: 113, + EBADR: 114, + EXFULL: 115, + ENOANO: 104, + EBADRQC: 103, + EBADSLT: 102, + EDEADLOCK: 16, + EBFONT: 101, + ENOSTR: 100, + ENODATA: 116, + ETIME: 117, + ENOSR: 118, + ENONET: 119, + ENOPKG: 120, + EREMOTE: 121, + ENOLINK: 47, + EADV: 122, + ESRMNT: 123, + ECOMM: 124, + EPROTO: 65, + EMULTIHOP: 36, + EDOTDOT: 125, + EBADMSG: 9, + ENOTUNIQ: 126, + EBADFD: 127, + EREMCHG: 128, + ELIBACC: 129, + ELIBBAD: 130, + ELIBSCN: 131, + ELIBMAX: 132, + ELIBEXEC: 133, + ENOSYS: 52, + ENOTEMPTY: 55, + ENAMETOOLONG: 37, + ELOOP: 32, + EOPNOTSUPP: 138, + EPFNOSUPPORT: 139, + ECONNRESET: 15, + ENOBUFS: 42, + EAFNOSUPPORT: 5, + EPROTOTYPE: 67, + ENOTSOCK: 57, + ENOPROTOOPT: 50, + ESHUTDOWN: 140, + ECONNREFUSED: 14, + EADDRINUSE: 3, + ECONNABORTED: 13, + ENETUNREACH: 40, + ENETDOWN: 38, + ETIMEDOUT: 73, + EHOSTDOWN: 142, + EHOSTUNREACH: 23, + EINPROGRESS: 26, + EALREADY: 7, + EDESTADDRREQ: 17, + EMSGSIZE: 35, + EPROTONOSUPPORT: 66, + ESOCKTNOSUPPORT: 137, + EADDRNOTAVAIL: 4, + ENETRESET: 39, + EISCONN: 30, + ENOTCONN: 53, + ETOOMANYREFS: 141, + EUSERS: 136, + EDQUOT: 19, + ESTALE: 72, + ENOTSUP: 138, + ENOMEDIUM: 148, + EILSEQ: 25, + EOVERFLOW: 61, + ECANCELED: 11, + ENOTRECOVERABLE: 56, + EOWNERDEAD: 62, + ESTRPIPE: 135, + }; + BindingError = Module["BindingError"] = extendError(Error, "BindingError"); + init_emval(); + PureVirtualError = Module["PureVirtualError"] = extendError(Error, "PureVirtualError"); + embind_init_charCodes(); + init_embind(); + InternalError = Module["InternalError"] = extendError(Error, "InternalError"); + init_ClassHandle(); + init_RegisteredPointer(); + UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError"); + var GLctx; + WebGPU.initManagers(); + for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i)); + var miniTempWebGLFloatBuffersStorage = new Float32Array(288); + for (var i = 0; i < 288; ++i) { + miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i + 1); + } + var __miniTempWebGLIntBuffersStorage = new Int32Array(288); + for (var i = 0; i < 288; ++i) { + __miniTempWebGLIntBuffers[i] = __miniTempWebGLIntBuffersStorage.subarray(0, i + 1); + } + var decodeBase64 = + typeof atob == "function" + ? atob + : function (input) { + var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + var output = ""; + var chr1, chr2, chr3; + var enc1, enc2, enc3, enc4; + var i = 0; + input = input.replace(/[^A-Za-z0-9+/=]/g, ""); + do { + enc1 = keyStr.indexOf(input.charAt(i++)); + enc2 = keyStr.indexOf(input.charAt(i++)); + enc3 = keyStr.indexOf(input.charAt(i++)); + enc4 = keyStr.indexOf(input.charAt(i++)); + chr1 = (enc1 << 2) | (enc2 >> 4); + chr2 = ((enc2 & 15) << 4) | (enc3 >> 2); + chr3 = ((enc3 & 3) << 6) | enc4; + output = output + String.fromCharCode(chr1); + if (enc3 !== 64) { + output = output + String.fromCharCode(chr2); + } + if (enc4 !== 64) { + output = output + String.fromCharCode(chr3); + } + } while (i < input.length); + return output; + }; + function intArrayFromBase64(s) { + if (typeof ENVIRONMENT_IS_NODE == "boolean" && ENVIRONMENT_IS_NODE) { + var buf = Buffer.from(s, "base64"); + return new Uint8Array(buf["buffer"], buf["byteOffset"], buf["byteLength"]); + } + try { + var decoded = decodeBase64(s); + var bytes = new Uint8Array(decoded.length); + for (var i = 0; i < decoded.length; ++i) { + bytes[i] = decoded.charCodeAt(i); + } + return bytes; + } catch (_) { + throw new Error("Converting base64 string to bytes failed."); + } + } + function checkIncomingModuleAPI() { + ignoredModuleProp("fetchSettings"); + } + var asmLibraryArg = { + HaveOffsetConverter: HaveOffsetConverter, + __assert_fail: ___assert_fail, + __cxa_allocate_exception: ___cxa_allocate_exception, + __cxa_throw: ___cxa_throw, + __syscall_dup: ___syscall_dup, + __syscall_fcntl64: ___syscall_fcntl64, + __syscall_fstat64: ___syscall_fstat64, + __syscall_ioctl: ___syscall_ioctl, + __syscall_lstat64: ___syscall_lstat64, + __syscall_newfstatat: ___syscall_newfstatat, + __syscall_openat: ___syscall_openat, + __syscall_stat64: ___syscall_stat64, + _dlinit: __dlinit, + _dlopen_js: __dlopen_js, + _dlsym_js: __dlsym_js, + _embind_create_inheriting_constructor: __embind_create_inheriting_constructor, + _embind_finalize_value_object: __embind_finalize_value_object, + _embind_register_bigint: __embind_register_bigint, + _embind_register_bool: __embind_register_bool, + _embind_register_class: __embind_register_class, + _embind_register_class_class_function: __embind_register_class_class_function, + _embind_register_class_constructor: __embind_register_class_constructor, + _embind_register_class_function: __embind_register_class_function, + _embind_register_class_property: __embind_register_class_property, + _embind_register_emval: __embind_register_emval, + _embind_register_float: __embind_register_float, + _embind_register_function: __embind_register_function, + _embind_register_integer: __embind_register_integer, + _embind_register_memory_view: __embind_register_memory_view, + _embind_register_std_string: __embind_register_std_string, + _embind_register_std_wstring: __embind_register_std_wstring, + _embind_register_value_object: __embind_register_value_object, + _embind_register_value_object_field: __embind_register_value_object_field, + _embind_register_void: __embind_register_void, + _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic, + _emval_as: __emval_as, + _emval_call_void_method: __emval_call_void_method, + _emval_decref: __emval_decref, + _emval_get_global: __emval_get_global, + _emval_get_method_caller: __emval_get_method_caller, + _emval_get_property: __emval_get_property, + _emval_incref: __emval_incref, + _emval_instanceof: __emval_instanceof, + _emval_new_cstring: __emval_new_cstring, + _emval_run_destructors: __emval_run_destructors, + _emval_set_property: __emval_set_property, + _emval_take_value: __emval_take_value, + _emval_typeof: __emval_typeof, + _gmtime_js: __gmtime_js, + _localtime_js: __localtime_js, + _mktime_js: __mktime_js, + _mmap_js: __mmap_js, + _munmap_js: __munmap_js, + _tzset_js: __tzset_js, + abort: _abort, + emscripten_asm_const_int: _emscripten_asm_const_int, + emscripten_date_now: _emscripten_date_now, + emscripten_get_heap_max: _emscripten_get_heap_max, + emscripten_get_now: _emscripten_get_now, + emscripten_memcpy_big: _emscripten_memcpy_big, + emscripten_pc_get_function: _emscripten_pc_get_function, + emscripten_resize_heap: _emscripten_resize_heap, + emscripten_stack_snapshot: _emscripten_stack_snapshot, + emscripten_stack_unwind_buffer: _emscripten_stack_unwind_buffer, + emscripten_webgl_create_context: _emscripten_webgl_create_context, + emscripten_webgl_destroy_context: _emscripten_webgl_destroy_context, + emscripten_webgl_get_context_attributes: _emscripten_webgl_get_context_attributes, + emscripten_webgl_get_current_context: _emscripten_webgl_get_current_context, + emscripten_webgl_init_context_attributes: _emscripten_webgl_init_context_attributes, + emscripten_webgl_make_context_current: _emscripten_webgl_make_context_current, + emscripten_webgpu_export_bind_group_layout: _emscripten_webgpu_export_bind_group_layout, + emscripten_webgpu_export_device: _emscripten_webgpu_export_device, + emscripten_webgpu_export_sampler: _emscripten_webgpu_export_sampler, + emscripten_webgpu_export_texture: _emscripten_webgpu_export_texture, + emscripten_webgpu_get_device: _emscripten_webgpu_get_device, + emscripten_webgpu_import_bind_group: _emscripten_webgpu_import_bind_group, + emscripten_webgpu_import_texture: _emscripten_webgpu_import_texture, + emscripten_webgpu_release_js_handle: _emscripten_webgpu_release_js_handle, + environ_get: _environ_get, + environ_sizes_get: _environ_sizes_get, + exit: _exit, + fd_close: _fd_close, + fd_read: _fd_read, + fd_seek: _fd_seek, + fd_write: _fd_write, + getentropy: _getentropy, + glActiveTexture: _glActiveTexture, + glAttachShader: _glAttachShader, + glBindAttribLocation: _glBindAttribLocation, + glBindBuffer: _glBindBuffer, + glBindBufferBase: _glBindBufferBase, + glBindFramebuffer: _glBindFramebuffer, + glBindTexture: _glBindTexture, + glBindVertexArray: _glBindVertexArray, + glBufferData: _glBufferData, + glClientWaitSync: _glClientWaitSync, + glCompileShader: _glCompileShader, + glCreateProgram: _glCreateProgram, + glCreateShader: _glCreateShader, + glDeleteBuffers: _glDeleteBuffers, + glDeleteFramebuffers: _glDeleteFramebuffers, + glDeleteProgram: _glDeleteProgram, + glDeleteShader: _glDeleteShader, + glDeleteSync: _glDeleteSync, + glDeleteTextures: _glDeleteTextures, + glDeleteVertexArrays: _glDeleteVertexArrays, + glDisable: _glDisable, + glDisableVertexAttribArray: _glDisableVertexAttribArray, + glDrawArrays: _glDrawArrays, + glDrawBuffers: _glDrawBuffers, + glEnableVertexAttribArray: _glEnableVertexAttribArray, + glFenceSync: _glFenceSync, + glFinish: _glFinish, + glFlush: _glFlush, + glFramebufferTexture2D: _glFramebufferTexture2D, + glFramebufferTextureLayer: _glFramebufferTextureLayer, + glGenBuffers: _glGenBuffers, + glGenFramebuffers: _glGenFramebuffers, + glGenTextures: _glGenTextures, + glGenVertexArrays: _glGenVertexArrays, + glGetAttribLocation: _glGetAttribLocation, + glGetError: _glGetError, + glGetIntegerv: _glGetIntegerv, + glGetProgramiv: _glGetProgramiv, + glGetShaderInfoLog: _glGetShaderInfoLog, + glGetShaderiv: _glGetShaderiv, + glGetString: _glGetString, + glGetUniformBlockIndex: _glGetUniformBlockIndex, + glGetUniformLocation: _glGetUniformLocation, + glLinkProgram: _glLinkProgram, + glPixelStorei: _glPixelStorei, + glReadPixels: _glReadPixels, + glShaderSource: _glShaderSource, + glTexImage2D: _glTexImage2D, + glTexParameterfv: _glTexParameterfv, + glTexParameteri: _glTexParameteri, + glTexStorage2D: _glTexStorage2D, + glTexStorage3D: _glTexStorage3D, + glTexSubImage2D: _glTexSubImage2D, + glTexSubImage3D: _glTexSubImage3D, + glUniform1f: _glUniform1f, + glUniform1i: _glUniform1i, + glUniform2fv: _glUniform2fv, + glUniform4fv: _glUniform4fv, + glUniform4iv: _glUniform4iv, + glUniformBlockBinding: _glUniformBlockBinding, + glUniformMatrix4fv: _glUniformMatrix4fv, + glUseProgram: _glUseProgram, + glVertexAttribPointer: _glVertexAttribPointer, + glViewport: _glViewport, + mediapipe_create_utility_canvas2d: mediapipe_create_utility_canvas2d, + mediapipe_find_canvas_event_target: _mediapipe_find_canvas_event_target, + mediapipe_import_external_texture: mediapipe_import_external_texture, + mediapipe_webgl_tex_image_drawable: _mediapipe_webgl_tex_image_drawable, + proc_exit: _proc_exit, + strftime: _strftime, + strftime_l: _strftime_l, + wgpuBindGroupLayoutRelease: _wgpuBindGroupLayoutRelease, + wgpuBindGroupRelease: _wgpuBindGroupRelease, + wgpuBufferGetMappedRange: _wgpuBufferGetMappedRange, + wgpuBufferReference: _wgpuBufferReference, + wgpuBufferRelease: _wgpuBufferRelease, + wgpuBufferUnmap: _wgpuBufferUnmap, + wgpuCommandBufferRelease: _wgpuCommandBufferRelease, + wgpuCommandEncoderBeginComputePass: _wgpuCommandEncoderBeginComputePass, + wgpuCommandEncoderBeginRenderPass: _wgpuCommandEncoderBeginRenderPass, + wgpuCommandEncoderCopyBufferToTexture: _wgpuCommandEncoderCopyBufferToTexture, + wgpuCommandEncoderCopyTextureToTexture: _wgpuCommandEncoderCopyTextureToTexture, + wgpuCommandEncoderFinish: _wgpuCommandEncoderFinish, + wgpuCommandEncoderRelease: _wgpuCommandEncoderRelease, + wgpuComputePassEncoderDispatchWorkgroups: _wgpuComputePassEncoderDispatchWorkgroups, + wgpuComputePassEncoderEnd: _wgpuComputePassEncoderEnd, + wgpuComputePassEncoderRelease: _wgpuComputePassEncoderRelease, + wgpuComputePassEncoderSetBindGroup: _wgpuComputePassEncoderSetBindGroup, + wgpuComputePassEncoderSetPipeline: _wgpuComputePassEncoderSetPipeline, + wgpuComputePipelineGetBindGroupLayout: _wgpuComputePipelineGetBindGroupLayout, + wgpuComputePipelineRelease: _wgpuComputePipelineRelease, + wgpuDeviceCreateBindGroup: _wgpuDeviceCreateBindGroup, + wgpuDeviceCreateBuffer: _wgpuDeviceCreateBuffer, + wgpuDeviceCreateCommandEncoder: _wgpuDeviceCreateCommandEncoder, + wgpuDeviceCreateComputePipeline: _wgpuDeviceCreateComputePipeline, + wgpuDeviceCreateRenderPipeline: _wgpuDeviceCreateRenderPipeline, + wgpuDeviceCreateSampler: _wgpuDeviceCreateSampler, + wgpuDeviceCreateShaderModule: _wgpuDeviceCreateShaderModule, + wgpuDeviceCreateTexture: _wgpuDeviceCreateTexture, + wgpuDeviceGetQueue: _wgpuDeviceGetQueue, + wgpuDeviceReference: _wgpuDeviceReference, + wgpuDeviceRelease: _wgpuDeviceRelease, + wgpuPipelineLayoutRelease: _wgpuPipelineLayoutRelease, + wgpuQuerySetRelease: _wgpuQuerySetRelease, + wgpuQueueRelease: _wgpuQueueRelease, + wgpuQueueSubmit: _wgpuQueueSubmit, + wgpuQueueWriteBuffer: _wgpuQueueWriteBuffer, + wgpuRenderPassEncoderDraw: _wgpuRenderPassEncoderDraw, + wgpuRenderPassEncoderEnd: _wgpuRenderPassEncoderEnd, + wgpuRenderPassEncoderRelease: _wgpuRenderPassEncoderRelease, + wgpuRenderPassEncoderSetBindGroup: _wgpuRenderPassEncoderSetBindGroup, + wgpuRenderPassEncoderSetPipeline: _wgpuRenderPassEncoderSetPipeline, + wgpuRenderPipelineGetBindGroupLayout: _wgpuRenderPipelineGetBindGroupLayout, + wgpuRenderPipelineRelease: _wgpuRenderPipelineRelease, + wgpuSamplerReference: _wgpuSamplerReference, + wgpuSamplerRelease: _wgpuSamplerRelease, + wgpuShaderModuleReference: _wgpuShaderModuleReference, + wgpuShaderModuleRelease: _wgpuShaderModuleRelease, + wgpuTextureCreateView: _wgpuTextureCreateView, + wgpuTextureDestroy: _wgpuTextureDestroy, + wgpuTextureReference: _wgpuTextureReference, + wgpuTextureRelease: _wgpuTextureRelease, + wgpuTextureViewReference: _wgpuTextureViewReference, + wgpuTextureViewRelease: _wgpuTextureViewRelease, + }; + var asm = createWasm(); + var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = + createExportWrapper("__wasm_call_ctors")); + var _malloc = (Module["_malloc"] = createExportWrapper("malloc")); + var _free = (Module["_free"] = createExportWrapper("free")); + var ___errno_location = (Module["___errno_location"] = createExportWrapper("__errno_location")); + var _fflush = (Module["_fflush"] = createExportWrapper("fflush")); + var ___getTypeName = (Module["___getTypeName"] = createExportWrapper("__getTypeName")); + var __embind_initialize_bindings = (Module["__embind_initialize_bindings"] = + createExportWrapper("_embind_initialize_bindings")); + var ___dl_seterr = (Module["___dl_seterr"] = createExportWrapper("__dl_seterr")); + var _emscripten_builtin_memalign = (Module["_emscripten_builtin_memalign"] = + createExportWrapper("emscripten_builtin_memalign")); + var _emscripten_stack_init = (Module["_emscripten_stack_init"] = function () { + return (_emscripten_stack_init = Module["_emscripten_stack_init"] = + Module["asm"]["emscripten_stack_init"]).apply(null, arguments); + }); + var _emscripten_stack_get_free = (Module["_emscripten_stack_get_free"] = function () { + return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = + Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments); + }); + var _emscripten_stack_get_base = (Module["_emscripten_stack_get_base"] = function () { + return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = + Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments); + }); + var _emscripten_stack_get_end = (Module["_emscripten_stack_get_end"] = function () { + return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = + Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments); + }); + var stackSave = (Module["stackSave"] = createExportWrapper("stackSave")); + var stackRestore = (Module["stackRestore"] = createExportWrapper("stackRestore")); + var stackAlloc = (Module["stackAlloc"] = createExportWrapper("stackAlloc")); + var _emscripten_stack_get_current = (Module["_emscripten_stack_get_current"] = function () { + return (_emscripten_stack_get_current = Module["_emscripten_stack_get_current"] = + Module["asm"]["emscripten_stack_get_current"]).apply(null, arguments); + }); + var ___cxa_is_pointer_type = (Module["___cxa_is_pointer_type"] = + createExportWrapper("__cxa_is_pointer_type")); + var dynCall_jii = (Module["dynCall_jii"] = createExportWrapper("dynCall_jii")); + var dynCall_iiiijij = (Module["dynCall_iiiijij"] = createExportWrapper("dynCall_iiiijij")); + var dynCall_ji = (Module["dynCall_ji"] = createExportWrapper("dynCall_ji")); + var dynCall_viji = (Module["dynCall_viji"] = createExportWrapper("dynCall_viji")); + var dynCall_jjj = (Module["dynCall_jjj"] = createExportWrapper("dynCall_jjj")); + var dynCall_jiii = (Module["dynCall_jiii"] = createExportWrapper("dynCall_jiii")); + var dynCall_iiiijj = (Module["dynCall_iiiijj"] = createExportWrapper("dynCall_iiiijj")); + var dynCall_viijj = (Module["dynCall_viijj"] = createExportWrapper("dynCall_viijj")); + var dynCall_viiijjj = (Module["dynCall_viiijjj"] = createExportWrapper("dynCall_viiijjj")); + var dynCall_vij = (Module["dynCall_vij"] = createExportWrapper("dynCall_vij")); + var dynCall_viijii = (Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii")); + var dynCall_vijjj = (Module["dynCall_vijjj"] = createExportWrapper("dynCall_vijjj")); + var dynCall_vj = (Module["dynCall_vj"] = createExportWrapper("dynCall_vj")); + var dynCall_viij = (Module["dynCall_viij"] = createExportWrapper("dynCall_viij")); + var dynCall_viiiiij = (Module["dynCall_viiiiij"] = createExportWrapper("dynCall_viiiiij")); + var dynCall_iijjiiii = (Module["dynCall_iijjiiii"] = createExportWrapper("dynCall_iijjiiii")); + var dynCall_jiji = (Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji")); + var dynCall_iiiiij = (Module["dynCall_iiiiij"] = createExportWrapper("dynCall_iiiiij")); + var dynCall_iiiiijj = (Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj")); + var dynCall_iiiiiijj = (Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj")); + var ___start_em_js = (Module["___start_em_js"] = 514739); + var ___stop_em_js = (Module["___stop_em_js"] = 515259); + Module["addRunDependency"] = addRunDependency; + Module["removeRunDependency"] = removeRunDependency; + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createDevice"] = FS.createDevice; + Module["FS_unlink"] = FS.unlink; + Module["GL"] = GL; + var unexportedRuntimeSymbols = [ + "run", + "UTF8ArrayToString", + "UTF8ToString", + "stringToUTF8Array", + "stringToUTF8", + "lengthBytesUTF8", + "addOnPreRun", + "addOnInit", + "addOnPreMain", + "addOnExit", + "addOnPostRun", + "FS_createFolder", + "FS_createLink", + "getLEB", + "getFunctionTables", + "alignFunctionTables", + "registerFunctions", + "prettyPrint", + "getCompilerSetting", + "out", + "err", + "callMain", + "abort", + "keepRuntimeAlive", + "wasmMemory", + "stackAlloc", + "stackSave", + "stackRestore", + "getTempRet0", + "setTempRet0", + "writeStackCookie", + "checkStackCookie", + "ptrToString", + "zeroMemory", + "stringToNewUTF8", + "exitJS", + "getHeapMax", + "emscripten_realloc_buffer", + "ENV", + "ERRNO_CODES", + "ERRNO_MESSAGES", + "setErrNo", + "inetPton4", + "inetNtop4", + "inetPton6", + "inetNtop6", + "readSockaddr", + "writeSockaddr", + "DNS", + "getHostByName", + "Protocols", + "Sockets", + "getRandomDevice", + "warnOnce", + "traverseStack", + "UNWIND_CACHE", + "convertPCtoSourceLocation", + "readEmAsmArgsArray", + "readEmAsmArgs", + "runEmAsmFunction", + "runMainThreadEmAsm", + "jstoi_q", + "jstoi_s", + "getExecutableName", + "listenOnce", + "autoResumeAudioContext", + "dynCallLegacy", + "getDynCaller", + "dynCall", + "handleException", + "runtimeKeepalivePush", + "runtimeKeepalivePop", + "callUserCallback", + "maybeExit", + "safeSetTimeout", + "asmjsMangle", + "asyncLoad", + "alignMemory", + "mmapAlloc", + "writeI53ToI64", + "writeI53ToI64Clamped", + "writeI53ToI64Signaling", + "writeI53ToU64Clamped", + "writeI53ToU64Signaling", + "readI53FromI64", + "readI53FromU64", + "convertI32PairToI53", + "convertI32PairToI53Checked", + "convertU32PairToI53", + "getCFunc", + "ccall", + "cwrap", + "uleb128Encode", + "sigToWasmTypes", + "generateFuncType", + "convertJsFunctionToWasm", + "freeTableIndexes", + "functionsInTableMap", + "getEmptyTableSlot", + "updateTableMap", + "addFunction", + "removeFunction", + "reallyNegative", + "unSign", + "strLen", + "reSign", + "formatString", + "setValue", + "getValue", + "PATH", + "PATH_FS", + "intArrayFromString", + "intArrayToString", + "AsciiToString", + "stringToAscii", + "UTF16Decoder", + "UTF16ToString", + "stringToUTF16", + "lengthBytesUTF16", + "UTF32ToString", + "stringToUTF32", + "lengthBytesUTF32", + "allocateUTF8", + "allocateUTF8OnStack", + "writeStringToMemory", + "writeArrayToMemory", + "writeAsciiToMemory", + "SYSCALLS", + "getSocketFromFD", + "getSocketAddress", + "JSEvents", + "registerKeyEventCallback", + "specialHTMLTargets", + "findEventTarget", + "findCanvasEventTarget", + "getBoundingClientRect", + "fillMouseEventData", + "registerMouseEventCallback", + "registerWheelEventCallback", + "registerUiEventCallback", + "registerFocusEventCallback", + "fillDeviceOrientationEventData", + "registerDeviceOrientationEventCallback", + "fillDeviceMotionEventData", + "registerDeviceMotionEventCallback", + "screenOrientation", + "fillOrientationChangeEventData", + "registerOrientationChangeEventCallback", + "fillFullscreenChangeEventData", + "registerFullscreenChangeEventCallback", + "JSEvents_requestFullscreen", + "JSEvents_resizeCanvasForFullscreen", + "registerRestoreOldStyle", + "hideEverythingExceptGivenElement", + "restoreHiddenElements", + "setLetterbox", + "currentFullscreenStrategy", + "restoreOldWindowedStyle", + "softFullscreenResizeWebGLRenderTarget", + "doRequestFullscreen", + "fillPointerlockChangeEventData", + "registerPointerlockChangeEventCallback", + "registerPointerlockErrorEventCallback", + "requestPointerLock", + "fillVisibilityChangeEventData", + "registerVisibilityChangeEventCallback", + "registerTouchEventCallback", + "fillGamepadEventData", + "registerGamepadEventCallback", + "registerBeforeUnloadEventCallback", + "fillBatteryEventData", + "battery", + "registerBatteryEventCallback", + "setCanvasElementSize", + "getCanvasElementSize", + "demangle", + "demangleAll", + "jsStackTrace", + "stackTrace", + "ExitStatus", + "getEnvStrings", + "checkWasiClock", + "doReadv", + "doWritev", + "dlopenMissingError", + "createDyncallWrapper", + "setImmediateWrapped", + "clearImmediateWrapped", + "polyfillSetImmediate", + "uncaughtExceptionCount", + "exceptionLast", + "exceptionCaught", + "ExceptionInfo", + "exception_addRef", + "exception_decRef", + "Browser", + "setMainLoop", + "wget", + "FS", + "MEMFS", + "TTY", + "PIPEFS", + "SOCKFS", + "_setNetworkCallback", + "tempFixedLengthArray", + "miniTempWebGLFloatBuffers", + "heapObjectForWebGLType", + "heapAccessShiftForWebGLHeap", + "emscriptenWebGLGet", + "computeUnpackAlignedImageSize", + "emscriptenWebGLGetTexPixelData", + "emscriptenWebGLGetUniform", + "webglGetUniformLocation", + "webglPrepareUniformLocationsBeforeFirstUse", + "webglGetLeftBracePos", + "emscriptenWebGLGetVertexAttrib", + "emscriptenWebGLGetBufferBinding", + "emscriptenWebGLValidateMapBufferTarget", + "writeGLArray", + "AL", + "SDL_unicode", + "SDL_ttfContext", + "SDL_audio", + "SDL", + "SDL_gfx", + "GLUT", + "EGL", + "GLFW_Window", + "GLFW", + "GLEW", + "IDBStore", + "runAndAbortIfError", + "emscriptenWebGLGetIndexed", + "WebGPU", + "JsValStore", + "ALLOC_NORMAL", + "ALLOC_STACK", + "allocate", + "InternalError", + "BindingError", + "UnboundTypeError", + "PureVirtualError", + "init_embind", + "throwInternalError", + "throwBindingError", + "throwUnboundTypeError", + "ensureOverloadTable", + "exposePublicSymbol", + "replacePublicSymbol", + "extendError", + "createNamedFunction", + "embindRepr", + "registeredInstances", + "getBasestPointer", + "registerInheritedInstance", + "unregisterInheritedInstance", + "getInheritedInstance", + "getInheritedInstanceCount", + "getLiveInheritedInstances", + "registeredTypes", + "awaitingDependencies", + "typeDependencies", + "registeredPointers", + "registerType", + "whenDependentTypesAreResolved", + "embind_charCodes", + "embind_init_charCodes", + "readLatin1String", + "getTypeName", + "heap32VectorToArray", + "requireRegisteredType", + "getShiftFromSize", + "integerReadValueFromPointer", + "enumReadValueFromPointer", + "floatReadValueFromPointer", + "simpleReadValueFromPointer", + "runDestructors", + "new_", + "craftInvokerFunction", + "embind__requireFunction", + "tupleRegistrations", + "structRegistrations", + "genericPointerToWireType", + "constNoSmartPtrRawPointerToWireType", + "nonConstNoSmartPtrRawPointerToWireType", + "init_RegisteredPointer", + "RegisteredPointer", + "RegisteredPointer_getPointee", + "RegisteredPointer_destructor", + "RegisteredPointer_deleteObject", + "RegisteredPointer_fromWireType", + "runDestructor", + "releaseClassHandle", + "finalizationRegistry", + "detachFinalizer_deps", + "detachFinalizer", + "attachFinalizer", + "makeClassHandle", + "init_ClassHandle", + "ClassHandle", + "ClassHandle_isAliasOf", + "throwInstanceAlreadyDeleted", + "ClassHandle_clone", + "ClassHandle_delete", + "deletionQueue", + "ClassHandle_isDeleted", + "ClassHandle_deleteLater", + "flushPendingDeletes", + "delayFunction", + "setDelayFunction", + "RegisteredClass", + "shallowCopyInternalPointer", + "downcastPointer", + "upcastPointer", + "validateThis", + "char_0", + "char_9", + "makeLegalFunctionName", + "emval_handle_array", + "emval_free_list", + "emval_symbols", + "init_emval", + "count_emval_handles", + "get_first_emval", + "getStringOrSymbol", + "Emval", + "emval_newers", + "craftEmvalAllocator", + "emval_get_global", + "emval_lookupTypes", + "emval_allocateDestructors", + "emval_methodCallers", + "emval_addMethodCaller", + "emval_registeredMethods", + ]; + unexportedRuntimeSymbols.forEach(unexportedRuntimeSymbol); + var missingLibrarySymbols = [ + "inetPton4", + "inetNtop4", + "inetPton6", + "inetNtop6", + "readSockaddr", + "writeSockaddr", + "getHostByName", + "traverseStack", + "convertPCtoSourceLocation", + "runMainThreadEmAsm", + "jstoi_s", + "listenOnce", + "autoResumeAudioContext", + "runtimeKeepalivePush", + "runtimeKeepalivePop", + "asmjsMangle", + "writeI53ToI64Clamped", + "writeI53ToI64Signaling", + "writeI53ToU64Clamped", + "writeI53ToU64Signaling", + "convertU32PairToI53", + "getCFunc", + "ccall", + "cwrap", + "uleb128Encode", + "sigToWasmTypes", + "generateFuncType", + "convertJsFunctionToWasm", + "getEmptyTableSlot", + "updateTableMap", + "addFunction", + "removeFunction", + "reallyNegative", + "unSign", + "strLen", + "reSign", + "formatString", + "intArrayToString", + "AsciiToString", + "stringToAscii", + "allocateUTF8OnStack", + "writeStringToMemory", + "getSocketFromFD", + "getSocketAddress", + "registerKeyEventCallback", + "getBoundingClientRect", + "fillMouseEventData", + "registerMouseEventCallback", + "registerWheelEventCallback", + "registerUiEventCallback", + "registerFocusEventCallback", + "fillDeviceOrientationEventData", + "registerDeviceOrientationEventCallback", + "fillDeviceMotionEventData", + "registerDeviceMotionEventCallback", + "screenOrientation", + "fillOrientationChangeEventData", + "registerOrientationChangeEventCallback", + "fillFullscreenChangeEventData", + "registerFullscreenChangeEventCallback", + "JSEvents_requestFullscreen", + "JSEvents_resizeCanvasForFullscreen", + "registerRestoreOldStyle", + "hideEverythingExceptGivenElement", + "restoreHiddenElements", + "setLetterbox", + "softFullscreenResizeWebGLRenderTarget", + "doRequestFullscreen", + "fillPointerlockChangeEventData", + "registerPointerlockChangeEventCallback", + "registerPointerlockErrorEventCallback", + "requestPointerLock", + "fillVisibilityChangeEventData", + "registerVisibilityChangeEventCallback", + "registerTouchEventCallback", + "fillGamepadEventData", + "registerGamepadEventCallback", + "registerBeforeUnloadEventCallback", + "fillBatteryEventData", + "battery", + "registerBatteryEventCallback", + "setCanvasElementSize", + "getCanvasElementSize", + "stackTrace", + "checkWasiClock", + "createDyncallWrapper", + "setImmediateWrapped", + "clearImmediateWrapped", + "polyfillSetImmediate", + "exception_addRef", + "exception_decRef", + "_setNetworkCallback", + "emscriptenWebGLGetUniform", + "emscriptenWebGLGetVertexAttrib", + "emscriptenWebGLGetBufferBinding", + "emscriptenWebGLValidateMapBufferTarget", + "writeGLArray", + "SDL_unicode", + "SDL_ttfContext", + "SDL_audio", + "GLFW_Window", + "runAndAbortIfError", + "emscriptenWebGLGetIndexed", + "ALLOC_NORMAL", + "ALLOC_STACK", + "allocate", + "enumReadValueFromPointer", + "craftEmvalAllocator", + ]; + missingLibrarySymbols.forEach(missingLibrarySymbol); + var calledRun; + dependenciesFulfilled = function runCaller() { + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; + }; + function stackCheckInit() { + _emscripten_stack_init(); + writeStackCookie(); + } + function run(args) { + args = args || arguments_; + if (runDependencies > 0) { + return; + } + stackCheckInit(); + preRun(); + if (runDependencies > 0) { + return; + } + function doRun() { + if (calledRun) return; + calledRun = true; + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + readyPromiseResolve(Module); + if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); + assert( + !Module["_main"], + 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]', + ); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(function () { + setTimeout(function () { + Module["setStatus"](""); + }, 1); + doRun(); + }, 1); + } else { + doRun(); + } + checkStackCookie(); + } + function checkUnflushedContent() { + var oldOut = out; + var oldErr = err; + var has = false; + out = err = (x) => { + has = true; + }; + try { + _fflush(0); + ["stdout", "stderr"].forEach(function (name) { + var info = FS.analyzePath("/dev/" + name); + if (!info) return; + var stream = info.object; + var rdev = stream.rdev; + var tty = TTY.ttys[rdev]; + if (tty && tty.output && tty.output.length) { + has = true; + } + }); + } catch (e) {} + out = oldOut; + err = oldErr; + if (has) { + warnOnce( + "stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.", + ); + } + } + if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]]; + while (Module["preInit"].length > 0) { + Module["preInit"].pop()(); + } + } + run(); + + return createMediapipeSolutionsWasm.ready; + }; +})(); +if (typeof exports === "object" && typeof module === "object") + module.exports = createMediapipeSolutionsWasm; +else if (typeof define === "function" && define["amd"]) + define([], function () { + return createMediapipeSolutionsWasm; + }); +else if (typeof exports === "object") + exports["createMediapipeSolutionsWasm"] = createMediapipeSolutionsWasm; diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_simd_wasm_bin.wasm b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_simd_wasm_bin.wasm new file mode 100644 index 000000000..c5437a8f3 Binary files /dev/null and b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_simd_wasm_bin.wasm differ diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_wasm_bin.js b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_wasm_bin.js new file mode 100644 index 000000000..90e2ae00a --- /dev/null +++ b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_wasm_bin.js @@ -0,0 +1,11354 @@ +var createMediapipeSolutionsWasm = (() => { + var _scriptDir = + typeof document !== "undefined" && document.currentScript + ? document.currentScript.src + : undefined; + if (typeof __filename !== "undefined") _scriptDir = _scriptDir || __filename; + return function (createMediapipeSolutionsWasm) { + createMediapipeSolutionsWasm = createMediapipeSolutionsWasm || {}; + + var Module = + typeof createMediapipeSolutionsWasm != "undefined" ? createMediapipeSolutionsWasm : {}; + var readyPromiseResolve, readyPromiseReject; + Module["ready"] = new Promise(function (resolve, reject) { + readyPromiseResolve = resolve; + readyPromiseReject = reject; + }); + [ + "_main", + "_fflush", + "___getTypeName", + "__embind_initialize_bindings", + "onRuntimeInitialized", + ].forEach((prop) => { + if (!Object.getOwnPropertyDescriptor(Module["ready"], prop)) { + Object.defineProperty(Module["ready"], prop, { + get: () => + abort( + "You are getting " + + prop + + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js", + ), + set: () => + abort( + "You are setting " + + prop + + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js", + ), + }); + } + }); + var moduleOverrides = Object.assign({}, Module); + var arguments_ = []; + var thisProgram = "./this.program"; + var quit_ = (status, toThrow) => { + throw toThrow; + }; + var ENVIRONMENT_IS_WEB = typeof window == "object"; + var ENVIRONMENT_IS_WORKER = typeof importScripts == "function"; + var ENVIRONMENT_IS_NODE = + typeof process == "object" && + typeof process.versions == "object" && + typeof process.versions.node == "string"; + var ENVIRONMENT_IS_SHELL = + !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + if (Module["ENVIRONMENT"]) { + throw new Error( + "Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)", + ); + } + var scriptDirectory = ""; + function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; + } + var read_, readAsync, readBinary, setWindowTitle; + function logExceptionOnExit(e) { + if (e instanceof ExitStatus) return; + let toLog = e; + if (e && typeof e == "object" && e.stack) { + toLog = [e, e.stack]; + } + err("exiting due to exception: " + toLog); + } + if (ENVIRONMENT_IS_NODE) { + if (typeof process == "undefined" || !process.release || process.release.name !== "node") + throw new Error( + "not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)", + ); + var fs = require("fs"); + var nodePath = require("path"); + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = nodePath.dirname(scriptDirectory) + "/"; + } else { + scriptDirectory = __dirname + "/"; + } + read_ = (filename, binary) => { + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + return fs.readFileSync(filename, binary ? undefined : "utf8"); + }; + readBinary = (filename) => { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + readAsync = (filename, onload, onerror) => { + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + fs.readFile(filename, function (err, data) { + if (err) onerror(err); + else onload(data.buffer); + }); + }; + if (process["argv"].length > 1) { + thisProgram = process["argv"][1].replace(/\\/g, "/"); + } + arguments_ = process["argv"].slice(2); + process["on"]("uncaughtException", function (ex) { + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + process["on"]("unhandledRejection", function (reason) { + throw reason; + }); + quit_ = (status, toThrow) => { + if (keepRuntimeAlive()) { + process["exitCode"] = status; + throw toThrow; + } + logExceptionOnExit(toThrow); + process["exit"](status); + }; + Module["inspect"] = function () { + return "[Emscripten Module object]"; + }; + } else if (ENVIRONMENT_IS_SHELL) { + if ( + (typeof process == "object" && typeof require === "function") || + typeof window == "object" || + typeof importScripts == "function" + ) + throw new Error( + "not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)", + ); + if (typeof read != "undefined") { + read_ = function shell_read(f) { + return read(f); + }; + } + readBinary = function readBinary(f) { + let data; + if (typeof readbuffer == "function") { + return new Uint8Array(readbuffer(f)); + } + data = read(f, "binary"); + assert(typeof data == "object"); + return data; + }; + readAsync = function readAsync(f, onload, onerror) { + setTimeout(() => onload(readBinary(f)), 0); + }; + if (typeof scriptArgs != "undefined") { + arguments_ = scriptArgs; + } else if (typeof arguments != "undefined") { + arguments_ = arguments; + } + if (typeof quit == "function") { + quit_ = (status, toThrow) => { + logExceptionOnExit(toThrow); + quit(status); + }; + } + if (typeof print != "undefined") { + if (typeof console == "undefined") console = {}; + console.log = print; + console.warn = console.error = typeof printErr != "undefined" ? printErr : print; + } + } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = self.location.href; + } else if (typeof document != "undefined" && document.currentScript) { + scriptDirectory = document.currentScript.src; + } + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + if (scriptDirectory.indexOf("blob:") !== 0) { + scriptDirectory = scriptDirectory.substr( + 0, + scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1, + ); + } else { + scriptDirectory = ""; + } + if (!(typeof window == "object" || typeof importScripts == "function")) + throw new Error( + "not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)", + ); + { + read_ = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.send(null); + return xhr.responseText; + }; + if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + } + setWindowTitle = (title) => (document.title = title); + } else { + throw new Error("environment detection error"); + } + var out = Module["print"] || console.log.bind(console); + var err = Module["printErr"] || console.warn.bind(console); + Object.assign(Module, moduleOverrides); + moduleOverrides = null; + checkIncomingModuleAPI(); + if (Module["arguments"]) arguments_ = Module["arguments"]; + legacyModuleProp("arguments", "arguments_"); + if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; + legacyModuleProp("thisProgram", "thisProgram"); + if (Module["quit"]) quit_ = Module["quit"]; + legacyModuleProp("quit", "quit_"); + assert( + typeof Module["memoryInitializerPrefixURL"] == "undefined", + "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead", + ); + assert( + typeof Module["pthreadMainPrefixURL"] == "undefined", + "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead", + ); + assert( + typeof Module["cdInitializerPrefixURL"] == "undefined", + "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead", + ); + assert( + typeof Module["filePackagePrefixURL"] == "undefined", + "Module.filePackagePrefixURL option was removed, use Module.locateFile instead", + ); + assert( + typeof Module["read"] == "undefined", + "Module.read option was removed (modify read_ in JS)", + ); + assert( + typeof Module["readAsync"] == "undefined", + "Module.readAsync option was removed (modify readAsync in JS)", + ); + assert( + typeof Module["readBinary"] == "undefined", + "Module.readBinary option was removed (modify readBinary in JS)", + ); + assert( + typeof Module["setWindowTitle"] == "undefined", + "Module.setWindowTitle option was removed (modify setWindowTitle in JS)", + ); + assert( + typeof Module["TOTAL_MEMORY"] == "undefined", + "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY", + ); + legacyModuleProp("read", "read_"); + legacyModuleProp("readAsync", "readAsync"); + legacyModuleProp("readBinary", "readBinary"); + legacyModuleProp("setWindowTitle", "setWindowTitle"); + assert( + !ENVIRONMENT_IS_SHELL, + "shell environment detected but not enabled at build time. Add 'shell' to `-sENVIRONMENT` to enable.", + ); + var POINTER_SIZE = 4; + function legacyModuleProp(prop, newName) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get: function () { + abort( + "Module." + + prop + + " has been replaced with plain " + + newName + + " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)", + ); + }, + }); + } + } + function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort( + "`Module." + + prop + + "` was supplied but `" + + prop + + "` not included in INCOMING_MODULE_JS_API", + ); + } + } + function isExportedByForceFilesystem(name) { + return ( + name === "FS_createPath" || + name === "FS_createDataFile" || + name === "FS_createPreloadedFile" || + name === "FS_unlink" || + name === "addRunDependency" || + name === "FS_createLazyFile" || + name === "FS_createDevice" || + name === "removeRunDependency" + ); + } + function missingLibrarySymbol(sym) { + if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) { + Object.defineProperty(globalThis, sym, { + configurable: true, + get: function () { + var msg = + "`" + + sym + + "` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line"; + var librarySymbol = sym; + if (!librarySymbol.startsWith("_")) { + librarySymbol = "$" + sym; + } + msg += " (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE=" + librarySymbol + ")"; + if (isExportedByForceFilesystem(sym)) { + msg += + ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"; + } + warnOnce(msg); + return undefined; + }, + }); + } + } + function unexportedRuntimeSymbol(sym) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get: function () { + var msg = + "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)"; + if (isExportedByForceFilesystem(sym)) { + msg += + ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you"; + } + abort(msg); + }, + }); + } + } + var wasmBinary; + if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; + legacyModuleProp("wasmBinary", "wasmBinary"); + var noExitRuntime = Module["noExitRuntime"] || true; + legacyModuleProp("noExitRuntime", "noExitRuntime"); + if (typeof WebAssembly != "object") { + abort("no native wasm support detected"); + } + var wasmMemory; + var ABORT = false; + var EXITSTATUS; + function assert(condition, text) { + if (!condition) { + abort("Assertion failed" + (text ? ": " + text : "")); + } + } + var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined; + function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ""; + while (idx < endPtr) { + var u0 = heapOrArray[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode(((u0 & 31) << 6) | u1); + continue; + } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 248) != 240) + warnOnce( + "Invalid UTF-8 leading byte " + + ptrToString(u0) + + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!", + ); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } + } + return str; + } + function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""; + } + function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = (65536 + ((u & 1023) << 10)) | (u1 & 1023); + } + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | (u >> 6); + heap[outIdx++] = 128 | (u & 63); + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | (u >> 12); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 1114111) + warnOnce( + "Invalid Unicode code point " + + ptrToString(u) + + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).", + ); + heap[outIdx++] = 240 | (u >> 18); + heap[outIdx++] = 128 | ((u >> 12) & 63); + heap[outIdx++] = 128 | ((u >> 6) & 63); + heap[outIdx++] = 128 | (u & 63); + } + } + heap[outIdx] = 0; + return outIdx - startIdx; + } + function stringToUTF8(str, outPtr, maxBytesToWrite) { + assert( + typeof maxBytesToWrite == "number", + "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!", + ); + return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); + } + function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var c = str.charCodeAt(i); + if (c <= 127) { + len++; + } else if (c <= 2047) { + len += 2; + } else if (c >= 55296 && c <= 57343) { + len += 4; + ++i; + } else { + len += 3; + } + } + return len; + } + var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module["HEAP8"] = HEAP8 = new Int8Array(buf); + Module["HEAP16"] = HEAP16 = new Int16Array(buf); + Module["HEAP32"] = HEAP32 = new Int32Array(buf); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf); + Module["HEAPF32"] = HEAPF32 = new Float32Array(buf); + Module["HEAPF64"] = HEAPF64 = new Float64Array(buf); + } + var STACK_SIZE = 65536; + if (Module["STACK_SIZE"]) + assert( + STACK_SIZE === Module["STACK_SIZE"], + "the stack size can no longer be determined at runtime", + ); + var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216; + legacyModuleProp("INITIAL_MEMORY", "INITIAL_MEMORY"); + assert( + INITIAL_MEMORY >= STACK_SIZE, + "INITIAL_MEMORY should be larger than STACK_SIZE, was " + + INITIAL_MEMORY + + "! (STACK_SIZE=" + + STACK_SIZE + + ")", + ); + assert( + typeof Int32Array != "undefined" && + typeof Float64Array !== "undefined" && + Int32Array.prototype.subarray != undefined && + Int32Array.prototype.set != undefined, + "JS engine does not provide full typed array support", + ); + assert( + !Module["wasmMemory"], + "Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally", + ); + assert( + INITIAL_MEMORY == 16777216, + "Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically", + ); + var wasmTable; + function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + if (max == 0) { + max += 4; + } + HEAPU32[max >> 2] = 34821223; + HEAPU32[(max + 4) >> 2] = 2310721022; + HEAPU32[0] = 1668509029; + } + function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + if (max == 0) { + max += 4; + } + var cookie1 = HEAPU32[max >> 2]; + var cookie2 = HEAPU32[(max + 4) >> 2]; + if (cookie1 != 34821223 || cookie2 != 2310721022) { + abort( + "Stack overflow! Stack cookie has been overwritten at " + + ptrToString(max) + + ", expected hex dwords 0x89BACDFE and 0x2135467, but received " + + ptrToString(cookie2) + + " " + + ptrToString(cookie1), + ); + } + if (HEAPU32[0] !== 1668509029) { + abort("Runtime error: The application has corrupted its heap memory area (address zero)!"); + } + } + (function () { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 25459; + if (h8[0] !== 115 || h8[1] !== 99) + throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)"; + })(); + var __ATPRERUN__ = []; + var __ATINIT__ = []; + var __ATEXIT__ = []; + var __ATPOSTRUN__ = []; + var runtimeInitialized = false; + function keepRuntimeAlive() { + return noExitRuntime; + } + function preRun() { + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); + } + function initRuntime() { + assert(!runtimeInitialized); + runtimeInitialized = true; + checkStackCookie(); + if (!Module["noFSInit"] && !FS.init.initialized) FS.init(); + FS.ignorePermissions = false; + TTY.init(); + callRuntimeCallbacks(__ATINIT__); + } + function postRun() { + checkStackCookie(); + if (Module["postRun"]) { + if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]]; + while (Module["postRun"].length) { + addOnPostRun(Module["postRun"].shift()); + } + } + callRuntimeCallbacks(__ATPOSTRUN__); + } + function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); + } + function addOnInit(cb) { + __ATINIT__.unshift(cb); + } + function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); + } + assert( + Math.imul, + "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill", + ); + assert( + Math.fround, + "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill", + ); + assert( + Math.clz32, + "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill", + ); + assert( + Math.trunc, + "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill", + ); + var runDependencies = 0; + var runDependencyWatcher = null; + var dependenciesFulfilled = null; + var runDependencyTracking = {}; + function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } + } + function addRunDependency(id) { + runDependencies++; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != "undefined") { + runDependencyWatcher = setInterval(function () { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + err("still waiting on run dependencies:"); + } + err("dependency: " + dep); + } + if (shown) { + err("(end of list)"); + } + }, 1e4); + } + } else { + err("warning: run dependency added without ID"); + } + } + function removeRunDependency(id) { + runDependencies--; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + err("warning: run dependency removed without ID"); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } + } + function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what); + } + what = "Aborted(" + what + ")"; + err(what); + ABORT = true; + EXITSTATUS = 1; + var e = new WebAssembly.RuntimeError(what); + readyPromiseReject(e); + throw e; + } + var dataURIPrefix = "data:application/octet-stream;base64,"; + function isDataURI(filename) { + return filename.startsWith(dataURIPrefix); + } + function isFileURI(filename) { + return filename.startsWith("file://"); + } + function createExportWrapper(name, fixedasm) { + return function () { + var displayName = name; + var asm = fixedasm; + if (!fixedasm) { + asm = Module["asm"]; + } + assert( + runtimeInitialized, + "native function `" + displayName + "` called before runtime initialization", + ); + if (!asm[name]) { + assert(asm[name], "exported native function `" + displayName + "` not found"); + } + return asm[name].apply(null, arguments); + }; + } + var wasmBinaryFile; + wasmBinaryFile = "selfie_segmentation_solution_wasm_bin.wasm"; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw "both async and sync fetching of the wasm failed"; + } catch (err) { + abort(err); + } + } + function getBinaryPromise() { + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == "function" && !isFileURI(wasmBinaryFile)) { + return fetch(wasmBinaryFile, { credentials: "same-origin" }) + .then(function (response) { + if (!response["ok"]) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response["arrayBuffer"](); + }) + .catch(function () { + return getBinary(wasmBinaryFile); + }); + } else { + if (readAsync) { + return new Promise(function (resolve, reject) { + readAsync( + wasmBinaryFile, + function (response) { + resolve(new Uint8Array(response)); + }, + reject, + ); + }); + } + } + } + return Promise.resolve().then(function () { + return getBinary(wasmBinaryFile); + }); + } + function createWasm() { + var info = { env: asmLibraryArg, wasi_snapshot_preview1: asmLibraryArg }; + function receiveInstance(instance, module) { + var exports = instance.exports; + Module["asm"] = exports; + wasmMemory = Module["asm"]["memory"]; + assert(wasmMemory, "memory not found in wasm exports"); + updateGlobalBufferAndViews(wasmMemory.buffer); + wasmTable = Module["asm"]["__indirect_function_table"]; + assert(wasmTable, "table not found in wasm exports"); + addOnInit(Module["asm"]["__wasm_call_ctors"]); + removeRunDependency("wasm-instantiate"); + } + addRunDependency("wasm-instantiate"); + var trueModule = Module; + function receiveInstantiationResult(result) { + assert( + Module === trueModule, + "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?", + ); + trueModule = null; + receiveInstance(result["instance"]); + } + function instantiateArrayBuffer(receiver) { + return getBinaryPromise() + .then(function (binary) { + return WebAssembly.instantiate(binary, info); + }) + .then(function (instance) { + return instance; + }) + .then(receiver, function (reason) { + err("failed to asynchronously prepare wasm: " + reason); + if (isFileURI(wasmBinaryFile)) { + err( + "warning: Loading from a file URI (" + + wasmBinaryFile + + ") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing", + ); + } + abort(reason); + }); + } + function instantiateAsync() { + if ( + !wasmBinary && + typeof WebAssembly.instantiateStreaming == "function" && + !isDataURI(wasmBinaryFile) && + !isFileURI(wasmBinaryFile) && + !ENVIRONMENT_IS_NODE && + typeof fetch == "function" + ) { + return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, info); + return result.then(receiveInstantiationResult, function (reason) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + return instantiateArrayBuffer(receiveInstantiationResult); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiationResult); + } + } + if (Module["instantiateWasm"]) { + try { + var exports = Module["instantiateWasm"](info, receiveInstance); + return exports; + } catch (e) { + err("Module.instantiateWasm callback failed with error: " + e); + readyPromiseReject(e); + } + } + instantiateAsync().catch(readyPromiseReject); + return {}; + } + var tempDouble; + var tempI64; + var ASM_CONSTS = { + 512868: ($0) => { + const canvas = Emval.toValue($0); + const context = canvas.getContext("webgpu"); + return JsValStore.add(context.getCurrentTexture()); + }, + 513003: ($0, $1, $2, $3, $4) => { + const drawable = Emval.toValue($0); + const device = JsValStore.get($1); + const texture = JsValStore.get($2); + const width = $3; + const height = $4; + device.queue.copyExternalImageToTexture({ source: drawable }, { texture: texture }, [ + width, + height, + ]); + }, + 513254: ($0, $1, $2, $3) => { + const sourceExtTex = Emval.toValue($0); + const device = JsValStore.get($1); + const sampler = JsValStore.get($2); + const bgLayout = JsValStore.get($3); + const bindGroup = device.createBindGroup({ + layout: bgLayout, + entries: [ + { binding: 0, resource: sampler }, + { binding: 1, resource: sourceExtTex }, + ], + }); + return JsValStore.add(bindGroup); + }, + 513602: ($0, $1) => { + const inputArray = Emval.toValue($0); + const output = Emval.toValue($1); + const ctx = output.getContext("2d"); + const image_data = new ImageData(inputArray, output.width, output.height); + ctx.putImageData(image_data, 0, 0); + }, + 513826: ($0, $1) => { + const input = Emval.toValue($0); + const outputArray = Emval.toValue($1); + const ctx = input.getContext("2d"); + const data = ctx.getImageData(0, 0, input.width, input.height); + outputArray.set(data.data); + }, + 514030: ($0, $1) => { + const input = Emval.toValue($0); + const output = Emval.toValue($1); + const ctx = output.getContext("2d"); + ctx.drawImage(input, 0, 0); + }, + 514166: () => { + return !!Module["preinitializedWebGPUDevice"]; + }, + 514217: () => { + let init_once = true; + if (init_once) { + const cachedFindCanvasEventTarget = findCanvasEventTarget; + if (typeof cachedFindCanvasEventTarget !== "function") { + if (typeof console !== "undefined") { + console.error( + "Expected Emscripten global function " + + '"findCanvasEventTarget" not found. WebGL context creation ' + + "may fail.", + ); + } + return; + } + findCanvasEventTarget = function (target) { + if (target == 0) { + if (Module && Module.canvas) { + return Module.canvas; + } else if (Module && Module.canvasCssSelector) { + return cachedFindCanvasEventTarget(Module.canvasCssSelector); + } + if (typeof console !== "undefined") { + console.warn( + "Module properties canvas and canvasCssSelector not " + + "found during WebGL context creation.", + ); + } + } + return cachedFindCanvasEventTarget(target); + }; + init_once = false; + } + }, + 515002: () => { + return typeof wasmOffsetConverter !== "undefined"; + }, + }; + function mediapipe_import_external_texture(device_handle, source_handle) { + const device = WebGPU.mgrDevice.get(device_handle); + const source = Emval.toValue(source_handle); + const externalTexture = device.importExternalTexture({ source: source }); + return Emval.toHandle(externalTexture); + } + function mediapipe_create_utility_canvas2d() { + const canvas = document.createElement("canvas"); + canvas.style.display = "none"; + canvas.id = "canvas_2d"; + document.body.appendChild(canvas); + return Emval.toHandle(canvas); + } + function HaveOffsetConverter() { + return typeof wasmOffsetConverter !== "undefined"; + } + function _emscripten_set_main_loop_timing(mode, value) { + Browser.mainLoop.timingMode = mode; + Browser.mainLoop.timingValue = value; + if (!Browser.mainLoop.func) { + err( + "emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up.", + ); + return 1; + } + if (!Browser.mainLoop.running) { + Browser.mainLoop.running = true; + } + if (mode == 0) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() { + var timeUntilNextTick = + Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now()) | 0; + setTimeout(Browser.mainLoop.runner, timeUntilNextTick); + }; + Browser.mainLoop.method = "timeout"; + } else if (mode == 1) { + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() { + Browser.requestAnimationFrame(Browser.mainLoop.runner); + }; + Browser.mainLoop.method = "rAF"; + } else if (mode == 2) { + if (typeof setImmediate == "undefined") { + var setImmediates = []; + var emscriptenMainLoopMessageId = "setimmediate"; + var Browser_setImmediate_messageHandler = (event) => { + if ( + event.data === emscriptenMainLoopMessageId || + event.data.target === emscriptenMainLoopMessageId + ) { + event.stopPropagation(); + setImmediates.shift()(); + } + }; + addEventListener("message", Browser_setImmediate_messageHandler, true); + setImmediate = function Browser_emulated_setImmediate(func) { + setImmediates.push(func); + if (ENVIRONMENT_IS_WORKER) { + if (Module["setImmediates"] === undefined) Module["setImmediates"] = []; + Module["setImmediates"].push(func); + postMessage({ target: emscriptenMainLoopMessageId }); + } else postMessage(emscriptenMainLoopMessageId, "*"); + }; + } + Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() { + setImmediate(Browser.mainLoop.runner); + }; + Browser.mainLoop.method = "immediate"; + } + return 0; + } + var _emscripten_get_now; + if (ENVIRONMENT_IS_NODE) { + _emscripten_get_now = () => { + var t = process["hrtime"](); + return t[0] * 1e3 + t[1] / 1e6; + }; + } else _emscripten_get_now = () => performance.now(); + function _emscripten_webgl_do_commit_frame() { + if (!GL.currentContext || !GL.currentContext.GLctx) { + return -3; + } + if (GL.currentContext.defaultFbo) { + GL.blitOffscreenFramebuffer(GL.currentContext); + return 0; + } + if (!GL.currentContext.attributes.explicitSwapControl) { + return -3; + } + return 0; + } + function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; + } + var PATH = { + isAbs: (path) => path.charAt(0) === "/", + splitPath: (filename) => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^/]+?|)(\.[^./]*|))(?:[/]*)$/; + return splitPathRe.exec(filename).slice(1); + }, + normalizeArray: (parts, allowAboveRoot) => { + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === ".") { + parts.splice(i, 1); + } else if (last === "..") { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift(".."); + } + } + return parts; + }, + normalize: (path) => { + var isAbsolute = PATH.isAbs(path), + trailingSlash = path.substr(-1) === "/"; + path = PATH.normalizeArray( + path.split("/").filter((p) => !!p), + !isAbsolute, + ).join("/"); + if (!path && !isAbsolute) { + path = "."; + } + if (path && trailingSlash) { + path += "/"; + } + return (isAbsolute ? "/" : "") + path; + }, + dirname: (path) => { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + return "."; + } + if (dir) { + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }, + basename: (path) => { + if (path === "/") return "/"; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf("/"); + if (lastSlash === -1) return path; + return path.substr(lastSlash + 1); + }, + join: function () { + var paths = Array.prototype.slice.call(arguments); + return PATH.normalize(paths.join("/")); + }, + join2: (l, r) => { + return PATH.normalize(l + "/" + r); + }, + }; + function getRandomDevice() { + if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") { + var randomBuffer = new Uint8Array(1); + return () => { + crypto.getRandomValues(randomBuffer); + return randomBuffer[0]; + }; + } else if (ENVIRONMENT_IS_NODE) { + try { + var crypto_module = require("crypto"); + return () => crypto_module["randomBytes"](1)[0]; + } catch (e) {} + } + return () => + abort( + "no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };", + ); + } + var PATH_FS = { + resolve: function () { + var resolvedPath = "", + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = i >= 0 ? arguments[i] : FS.cwd(); + if (typeof path != "string") { + throw new TypeError("Arguments to path.resolve must be strings"); + } else if (!path) { + return ""; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = PATH.isAbs(path); + } + resolvedPath = PATH.normalizeArray( + resolvedPath.split("/").filter((p) => !!p), + !resolvedAbsolute, + ).join("/"); + return (resolvedAbsolute ? "/" : "") + resolvedPath || "."; + }, + relative: (from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== "") break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== "") break; + } + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split("/")); + var toParts = trim(to.split("/")); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push(".."); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join("/"); + }, + }; + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; + } + var TTY = { + ttys: [], + init: function () {}, + shutdown: function () {}, + register: function (dev, ops) { + TTY.ttys[dev] = { input: [], output: [], ops: ops }; + FS.registerDevice(dev, TTY.stream_ops); + }, + stream_ops: { + open: function (stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + }, + close: function (stream) { + stream.tty.ops.fsync(stream.tty); + }, + fsync: function (stream) { + stream.tty.ops.fsync(stream.tty); + }, + read: function (stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset + i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: function (stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset + i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }, + }, + default_tty_ops: { + get_char: function (tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + try { + bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1); + } catch (e) { + if (e.toString().includes("EOF")) bytesRead = 0; + else throw e; + } + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString("utf-8"); + } else { + result = null; + } + } else if (typeof window != "undefined" && typeof window.prompt == "function") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n"; + } + } else if (typeof readline == "function") { + result = readline(); + if (result !== null) { + result += "\n"; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + }, + put_char: function (tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }, + fsync: function (tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }, + }, + default_tty1_ops: { + put_char: function (tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) tty.output.push(val); + } + }, + fsync: function (tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }, + }, + }; + function zeroMemory(address, size) { + HEAPU8.fill(0, address, address + size); + return address; + } + function alignMemory(size, alignment) { + assert(alignment, "alignment argument is required"); + return Math.ceil(size / alignment) * alignment; + } + function mmapAlloc(size) { + size = alignMemory(size, 65536); + var ptr = _emscripten_builtin_memalign(65536, size); + if (!ptr) return 0; + return zeroMemory(ptr, size); + } + var MEMFS = { + ops_table: null, + mount: function (mount) { + return MEMFS.createNode(null, "/", 16384 | 511, 0); + }, + createNode: function (parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + throw new FS.ErrnoError(63); + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink, + }, + stream: { llseek: MEMFS.stream_ops.llseek }, + }, + file: { + node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync, + }, + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink, + }, + stream: {}, + }, + chrdev: { + node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, + stream: FS.chrdev_stream_ops, + }, + }; + } + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {}; + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; + node.contents = null; + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream; + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream; + } + node.timestamp = Date.now(); + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp; + } + return node; + }, + getFileDataAsTypedArray: function (node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); + return new Uint8Array(node.contents); + }, + expandFileStorage: function (node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max( + newCapacity, + (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125)) >>> 0, + ); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); + }, + resizeFileStorage: function (node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; + node.usedBytes = 0; + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); + } + node.usedBytes = newSize; + } + }, + node_ops: { + getattr: function (node) { + var attr = {}; + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes; + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length; + } else { + attr.size = 0; + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + }, + setattr: function (node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode; + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp; + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size); + } + }, + lookup: function (parent, name) { + throw FS.genericErrors[44]; + }, + mknod: function (parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev); + }, + rename: function (old_node, new_dir, new_name) { + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now(); + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir; + }, + unlink: function (parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + rmdir: function (parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name]; + parent.timestamp = Date.now(); + }, + readdir: function (node) { + var entries = [".", ".."]; + for (var key in node.contents) { + if (!Object.hasOwn(node.contents, key)) { + continue; + } + entries.push(key); + } + return entries; + }, + symlink: function (parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); + node.link = oldpath; + return node; + }, + readlink: function (node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }, + }, + stream_ops: { + read: function (stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) return 0; + var size = Math.min(stream.node.usedBytes - position, length); + assert(size >= 0); + if (size > 8 && contents.subarray) { + buffer.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; + } + return size; + }, + write: function (stream, buffer, offset, length, position, canOwn) { + assert(!(buffer instanceof ArrayBuffer)); + if (buffer.buffer === HEAP8.buffer) { + canOwn = false; + } + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + if (canOwn) { + assert(position === 0, "canOwn must imply no weird position inside the file"); + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer.subarray(offset, offset + length), position); + return length; + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer.subarray) { + node.contents.set(buffer.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i]; + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + }, + llseek: function (stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes; + } + } + if (position < 0) { + throw new FS.ErrnoError(28); + } + return position; + }, + allocate: function (stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + }, + mmap: function (stream, length, position, prot, flags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + if (!(flags & 2) && contents.buffer === buffer) { + allocated = false; + ptr = contents.byteOffset; + } else { + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.set(contents, ptr); + } + return { ptr: ptr, allocated: allocated }; + }, + msync: function (stream, buffer, offset, length, mmapFlags) { + MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + return 0; + }, + }, + }; + function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency("al " + url) : ""; + readAsync( + url, + (arrayBuffer) => { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep); + }, + (event) => { + if (onerror) { + onerror(); + } else { + throw 'Loading data file "' + url + '" failed.'; + } + }, + ); + if (dep) addRunDependency(dep); + } + var ERRNO_MESSAGES = { + 0: "Success", + 1: "Arg list too long", + 2: "Permission denied", + 3: "Address already in use", + 4: "Address not available", + 5: "Address family not supported by protocol family", + 6: "No more processes", + 7: "Socket already connected", + 8: "Bad file number", + 9: "Trying to read unreadable message", + 10: "Mount device busy", + 11: "Operation canceled", + 12: "No children", + 13: "Connection aborted", + 14: "Connection refused", + 15: "Connection reset by peer", + 16: "File locking deadlock error", + 17: "Destination address required", + 18: "Math arg out of domain of func", + 19: "Quota exceeded", + 20: "File exists", + 21: "Bad address", + 22: "File too large", + 23: "Host is unreachable", + 24: "Identifier removed", + 25: "Illegal byte sequence", + 26: "Connection already in progress", + 27: "Interrupted system call", + 28: "Invalid argument", + 29: "I/O error", + 30: "Socket is already connected", + 31: "Is a directory", + 32: "Too many symbolic links", + 33: "Too many open files", + 34: "Too many links", + 35: "Message too long", + 36: "Multihop attempted", + 37: "File or path name too long", + 38: "Network interface is not configured", + 39: "Connection reset by network", + 40: "Network is unreachable", + 41: "Too many open files in system", + 42: "No buffer space available", + 43: "No such device", + 44: "No such file or directory", + 45: "Exec format error", + 46: "No record locks available", + 47: "The link has been severed", + 48: "Not enough core", + 49: "No message of desired type", + 50: "Protocol not available", + 51: "No space left on device", + 52: "Function not implemented", + 53: "Socket is not connected", + 54: "Not a directory", + 55: "Directory not empty", + 56: "State not recoverable", + 57: "Socket operation on non-socket", + 59: "Not a typewriter", + 60: "No such device or address", + 61: "Value too large for defined data type", + 62: "Previous owner died", + 63: "Not super-user", + 64: "Broken pipe", + 65: "Protocol error", + 66: "Unknown protocol", + 67: "Protocol wrong type for socket", + 68: "Math result not representable", + 69: "Read only file system", + 70: "Illegal seek", + 71: "No such process", + 72: "Stale file handle", + 73: "Connection timed out", + 74: "Text file busy", + 75: "Cross-device link", + 100: "Device not a stream", + 101: "Bad font file fmt", + 102: "Invalid slot", + 103: "Invalid request code", + 104: "No anode", + 105: "Block device required", + 106: "Channel number out of range", + 107: "Level 3 halted", + 108: "Level 3 reset", + 109: "Link number out of range", + 110: "Protocol driver not attached", + 111: "No CSI structure available", + 112: "Level 2 halted", + 113: "Invalid exchange", + 114: "Invalid request descriptor", + 115: "Exchange full", + 116: "No data (for no delay io)", + 117: "Timer expired", + 118: "Out of streams resources", + 119: "Machine is not on the network", + 120: "Package not installed", + 121: "The object is remote", + 122: "Advertise error", + 123: "Srmount error", + 124: "Communication error on send", + 125: "Cross mount point (not really error)", + 126: "Given log. name not unique", + 127: "f.d. invalid for this operation", + 128: "Remote address changed", + 129: "Can access a needed shared lib", + 130: "Accessing a corrupted shared lib", + 131: ".lib section in a.out corrupted", + 132: "Attempting to link in too many libs", + 133: "Attempting to exec a shared library", + 135: "Streams pipe error", + 136: "Too many users", + 137: "Socket type not supported", + 138: "Not supported", + 139: "Protocol family not supported", + 140: "Can't send after socket shutdown", + 141: "Too many references", + 142: "Host is down", + 148: "No medium (in tape drive)", + 156: "Level 2 not synchronized", + }; + var ERRNO_CODES = {}; + function demangle(func) { + warnOnce("warning: build with -sDEMANGLE_SUPPORT to link in libcxxabi demangling"); + return func; + } + function demangleAll(text) { + var regex = /\b_Z[\w\d_]+/g; + return text.replace(regex, function (x) { + var y = demangle(x); + return x === y ? x : y + " [" + x + "]"; + }); + } + var FS = { + root: null, + mounts: [], + devices: {}, + streams: [], + nextInode: 1, + nameTable: null, + currentPath: "/", + initialized: false, + ignorePermissions: true, + ErrnoError: null, + genericErrors: {}, + filesystems: null, + syncFSRequests: 0, + lookupPath: (path, opts = {}) => { + path = PATH_FS.resolve(path); + if (!path) return { path: "", node: null }; + var defaults = { follow_mount: true, recurse_count: 0 }; + opts = Object.assign(defaults, opts); + if (opts.recurse_count > 8) { + throw new FS.ErrnoError(32); + } + var parts = path.split("/").filter((p) => !!p); + var current = FS.root; + var current_path = "/"; + for (var i = 0; i < parts.length; i++) { + var islast = i === parts.length - 1; + if (islast && opts.parent) { + break; + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || (islast && opts.follow_mount)) { + current = current.mounted.root; + } + } + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 }); + current = lookup.node; + if (count++ > 40) { + throw new FS.ErrnoError(32); + } + } + } + } + return { path: current_path, node: current }; + }, + getPath: (node) => { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path; + } + path = path ? node.name + "/" + path : node.name; + node = node.parent; + } + }, + hashName: (parentid, name) => { + var hash = 0; + for (var i = 0; i < name.length; i++) { + hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; + } + return ((parentid + hash) >>> 0) % FS.nameTable.length; + }, + hashAddNode: (node) => { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + }, + hashRemoveNode: (node) => { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + }, + lookupNode: (parent, name) => { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node; + } + } + return FS.lookup(parent, name); + }, + createNode: (parent, name, mode, rdev) => { + assert(typeof parent == "object"); + var node = new FS.FSNode(parent, name, mode, rdev); + FS.hashAddNode(node); + return node; + }, + destroyNode: (node) => { + FS.hashRemoveNode(node); + }, + isRoot: (node) => { + return node === node.parent; + }, + isMountpoint: (node) => { + return !!node.mounted; + }, + isFile: (mode) => { + return (mode & 61440) === 32768; + }, + isDir: (mode) => { + return (mode & 61440) === 16384; + }, + isLink: (mode) => { + return (mode & 61440) === 40960; + }, + isChrdev: (mode) => { + return (mode & 61440) === 8192; + }, + isBlkdev: (mode) => { + return (mode & 61440) === 24576; + }, + isFIFO: (mode) => { + return (mode & 61440) === 4096; + }, + isSocket: (mode) => { + return (mode & 49152) === 49152; + }, + flagModes: { r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090 }, + modeStringToFlags: (str) => { + var flags = FS.flagModes[str]; + if (typeof flags == "undefined") { + throw new Error("Unknown file open mode: " + str); + } + return flags; + }, + flagsToPermissionString: (flag) => { + var perms = ["r", "w", "rw"][flag & 3]; + if (flag & 512) { + perms += "w"; + } + return perms; + }, + nodePermissions: (node, perms) => { + if (FS.ignorePermissions) { + return 0; + } + if (perms.includes("r") && !(node.mode & 292)) { + return 2; + } else if (perms.includes("w") && !(node.mode & 146)) { + return 2; + } else if (perms.includes("x") && !(node.mode & 73)) { + return 2; + } + return 0; + }, + mayLookup: (dir) => { + var errCode = FS.nodePermissions(dir, "x"); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0; + }, + mayCreate: (dir, name) => { + try { + var node = FS.lookupNode(dir, name); + return 20; + } catch (e) {} + return FS.nodePermissions(dir, "wx"); + }, + mayDelete: (dir, name, isdir) => { + var node; + try { + node = FS.lookupNode(dir, name); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, "wx"); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + }, + mayOpen: (node, flags) => { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) { + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + }, + MAX_OPEN_FDS: 4096, + nextfd: (fd_start = 0, fd_end = FS.MAX_OPEN_FDS) => { + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + }, + getStream: (fd) => FS.streams[fd], + createStream: (stream, fd_start, fd_end) => { + if (!FS.FSStream) { + FS.FSStream = function () { + this.shared = {}; + }; + FS.FSStream.prototype = {}; + Object.defineProperties(FS.FSStream.prototype, { + object: { + get: function () { + return this.node; + }, + set: function (val) { + this.node = val; + }, + }, + isRead: { + get: function () { + return (this.flags & 2097155) !== 1; + }, + }, + isWrite: { + get: function () { + return (this.flags & 2097155) !== 0; + }, + }, + isAppend: { + get: function () { + return this.flags & 1024; + }, + }, + flags: { + get: function () { + return this.shared.flags; + }, + set: function (val) { + this.shared.flags = val; + }, + }, + position: { + get: function () { + return this.shared.position; + }, + set: function (val) { + this.shared.position = val; + }, + }, + }); + } + stream = Object.assign(new FS.FSStream(), stream); + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + }, + closeStream: (fd) => { + FS.streams[fd] = null; + }, + chrdev_stream_ops: { + open: (stream) => { + var device = FS.getDevice(stream.node.rdev); + stream.stream_ops = device.stream_ops; + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + }, + llseek: () => { + throw new FS.ErrnoError(70); + }, + }, + major: (dev) => dev >> 8, + minor: (dev) => dev & 255, + makedev: (ma, mi) => (ma << 8) | mi, + registerDevice: (dev, ops) => { + FS.devices[dev] = { stream_ops: ops }; + }, + getDevice: (dev) => FS.devices[dev], + getMounts: (mount) => { + var mounts = []; + var check = [mount]; + while (check.length) { + var m = check.pop(); + mounts.push(m); + check.push.apply(check, m.mounts); + } + return mounts; + }, + syncfs: (populate, callback) => { + if (typeof populate == "function") { + callback = populate; + populate = false; + } + FS.syncFSRequests++; + if (FS.syncFSRequests > 1) { + err( + "warning: " + + FS.syncFSRequests + + " FS.syncfs operations in flight at once, probably just doing extra work", + ); + } + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + function doCallback(errCode) { + assert(FS.syncFSRequests > 0); + FS.syncFSRequests--; + return callback(errCode); + } + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + } + mounts.forEach((mount) => { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + }, + mount: (type, opts, mountpoint) => { + if (typeof type == "string") { + throw type; + } + var root = mountpoint === "/"; + var pseudo = !mountpoint; + var node; + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + mountpoint = lookup.path; + node = lookup.node; + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + var mount = { type: type, opts: opts, mountpoint: mountpoint, mounts: [] }; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot; + } else if (node) { + node.mounted = mount; + if (node.mount) { + node.mount.mounts.push(mount); + } + } + return mountRoot; + }, + unmount: (mountpoint) => { + var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + Object.keys(FS.nameTable).forEach((hash) => { + var current = FS.nameTable[hash]; + while (current) { + var next = current.name_next; + if (mounts.includes(current.mount)) { + FS.destroyNode(current); + } + current = next; + } + }); + node.mounted = null; + var idx = node.mount.mounts.indexOf(mount); + assert(idx !== -1); + node.mount.mounts.splice(idx, 1); + }, + lookup: (parent, name) => { + return parent.node_ops.lookup(parent, name); + }, + mknod: (path, mode, dev) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === "." || name === "..") { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name, mode, dev); + }, + create: (path, mode) => { + mode = mode !== undefined ? mode : 438; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, + mkdir: (path, mode) => { + mode = mode !== undefined ? mode : 511; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + }, + mkdirTree: (path, mode) => { + var dirs = path.split("/"); + var d = ""; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += "/" + dirs[i]; + try { + FS.mkdir(d, mode); + } catch (e) { + if (e.errno != 20) throw e; + } + } + }, + mkdev: (path, mode, dev) => { + if (typeof dev == "undefined") { + dev = mode; + mode = 438; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + }, + symlink: (oldpath, newpath) => { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + }, + rename: (old_path, new_path) => { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + var lookup, old_dir, new_dir; + lookup = FS.lookupPath(old_path, { parent: true }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { parent: true }); + new_dir = lookup.node; + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(28); + } + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(55); + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) {} + if (old_node === new_node) { + return; + } + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + errCode = new_node + ? FS.mayDelete(new_dir, new_name, isdir) + : FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { + throw new FS.ErrnoError(10); + } + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + FS.hashAddNode(old_node); + } + }, + rmdir: (path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node); + }, + readdir: (path) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + }, + unlink: (path) => { + var lookup = FS.lookupPath(path, { parent: true }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node); + }, + readlink: (path) => { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + }, + stat: (path, dontFollow) => { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + }, + lstat: (path) => { + return FS.stat(path, true); + }, + chmod: (path, mode, dontFollow) => { + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { + mode: (mode & 4095) | (node.mode & ~4095), + timestamp: Date.now(), + }); + }, + lchmod: (path, mode) => { + FS.chmod(path, mode, true); + }, + fchmod: (fd, mode) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + }, + chown: (path, uid, gid, dontFollow) => { + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { follow: !dontFollow }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, { timestamp: Date.now() }); + }, + lchown: (path, uid, gid) => { + FS.chown(path, uid, gid, true); + }, + fchown: (fd, uid, gid) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + }, + truncate: (path, len) => { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { follow: true }); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, { size: len, timestamp: Date.now() }); + }, + ftruncate: (fd, len) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + }, + utime: (path, atime, mtime) => { + var lookup = FS.lookupPath(path, { follow: true }); + var node = lookup.node; + node.node_ops.setattr(node, { timestamp: Math.max(atime, mtime) }); + }, + open: (path, flags, mode) => { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags == "string" ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode == "undefined" ? 438 : mode; + if (flags & 64) { + mode = (mode & 4095) | 32768; + } else { + mode = 0; + } + var node; + if (typeof path == "object") { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { follow: !(flags & 131072) }); + node = lookup.node; + } catch (e) {} + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(20); + } + } else { + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + if (flags & 512 && !created) { + FS.truncate(node, 0); + } + flags &= ~(128 | 512 | 131072); + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + ungotten: [], + error: false, + }); + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module["logReadFiles"] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + } + } + return stream; + }, + close: (stream) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) stream.getdents = null; + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + }, + isClosed: (stream) => { + return stream.fd === null; + }, + llseek: (stream, offset, whence) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + }, + read: (stream, buffer, offset, length, position) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead; + }, + write: (stream, buffer, offset, length, position, canOwn) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + FS.llseek(stream, 0, 2); + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write( + stream, + buffer, + offset, + length, + position, + canOwn, + ); + if (!seeking) stream.position += bytesWritten; + return bytesWritten; + }, + allocate: (stream, offset, length) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + }, + mmap: (stream, length, position, prot, flags) => { + if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, length, position, prot, flags); + }, + msync: (stream, buffer, offset, length, mmapFlags) => { + if (!stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); + }, + munmap: (stream) => 0, + ioctl: (stream, cmd, arg) => { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + }, + readFile: (path, opts = {}) => { + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || "binary"; + if (opts.encoding !== "utf8" && opts.encoding !== "binary") { + throw new Error('Invalid encoding type "' + opts.encoding + '"'); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === "utf8") { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === "binary") { + ret = buf; + } + FS.close(stream); + return ret; + }, + writeFile: (path, data, opts = {}) => { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == "string") { + var buf = new Uint8Array(lengthBytesUTF8(data) + 1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn); + } else { + throw new Error("Unsupported data type"); + } + FS.close(stream); + }, + cwd: () => FS.currentPath, + chdir: (path) => { + var lookup = FS.lookupPath(path, { follow: true }); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, "x"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + }, + createDefaultDirectories: () => { + FS.mkdir("/tmp"); + FS.mkdir("/home"); + FS.mkdir("/home/web_user"); + }, + createDefaultDevices: () => { + FS.mkdir("/dev"); + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length, + }); + FS.mkdev("/dev/null", FS.makedev(1, 3)); + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev("/dev/tty", FS.makedev(5, 0)); + FS.mkdev("/dev/tty1", FS.makedev(6, 0)); + var random_device = getRandomDevice(); + FS.createDevice("/dev", "random", random_device); + FS.createDevice("/dev", "urandom", random_device); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp"); + }, + createSpecialDirectories: () => { + FS.mkdir("/proc"); + var proc_self = FS.mkdir("/proc/self"); + FS.mkdir("/proc/self/fd"); + FS.mount( + { + mount: () => { + var node = FS.createNode(proc_self, "fd", 16384 | 511, 73); + node.node_ops = { + lookup: (parent, name) => { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { mountpoint: "fake" }, + node_ops: { readlink: () => stream.path }, + }; + ret.parent = ret; + return ret; + }, + }; + return node; + }, + }, + {}, + "/proc/self/fd", + ); + }, + createStandardStreams: () => { + if (Module["stdin"]) { + FS.createDevice("/dev", "stdin", Module["stdin"]); + } else { + FS.symlink("/dev/tty", "/dev/stdin"); + } + if (Module["stdout"]) { + FS.createDevice("/dev", "stdout", null, Module["stdout"]); + } else { + FS.symlink("/dev/tty", "/dev/stdout"); + } + if (Module["stderr"]) { + FS.createDevice("/dev", "stderr", null, Module["stderr"]); + } else { + FS.symlink("/dev/tty1", "/dev/stderr"); + } + var stdin = FS.open("/dev/stdin", 0); + var stdout = FS.open("/dev/stdout", 1); + var stderr = FS.open("/dev/stderr", 1); + assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")"); + assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")"); + assert(stderr.fd === 2, "invalid handle for stderr (" + stderr.fd + ")"); + }, + ensureErrnoError: () => { + if (FS.ErrnoError) return; + FS.ErrnoError = function ErrnoError(errno, node) { + this.node = node; + this.setErrno = function (errno) { + this.errno = errno; + for (var key in ERRNO_CODES) { + if (ERRNO_CODES[key] === errno) { + this.code = key; + break; + } + } + }; + this.setErrno(errno); + this.message = ERRNO_MESSAGES[errno]; + if (this.stack) { + Object.defineProperty(this, "stack", { value: new Error().stack, writable: true }); + this.stack = demangleAll(this.stack); + } + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + [44].forEach((code) => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ""; + }); + }, + staticInit: () => { + FS.ensureErrnoError(); + FS.nameTable = new Array(4096); + FS.mount(MEMFS, {}, "/"); + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + FS.filesystems = { MEMFS: MEMFS }; + }, + init: (input, output, error) => { + assert( + !FS.init.initialized, + "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)", + ); + FS.init.initialized = true; + FS.ensureErrnoError(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams(); + }, + quit: () => { + FS.init.initialized = false; + _fflush(0); + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + }, + getMode: (canRead, canWrite) => { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode; + }, + findObject: (path, dontResolveLastLink) => { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (!ret.exists) { + return null; + } + return ret.object; + }, + analyzePath: (path, dontResolveLastLink) => { + try { + var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + path = lookup.path; + } catch (e) {} + var ret = { + isRoot: false, + exists: false, + error: 0, + name: null, + path: null, + object: null, + parentExists: false, + parentPath: null, + parentObject: null, + }; + try { + var lookup = FS.lookupPath(path, { parent: true }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === "/"; + } catch (e) { + ret.error = e.errno; + } + return ret; + }, + createPath: (parent, path, canRead, canWrite) => { + parent = typeof parent == "string" ? parent : FS.getPath(parent); + var parts = path.split("/").reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) {} + parent = current; + } + return current; + }, + createFile: (parent, name, properties, canRead, canWrite) => { + var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + }, + createDataFile: (parent, name, data, canRead, canWrite, canOwn) => { + var path = name; + if (parent) { + parent = typeof parent == "string" ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent; + } + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == "string") { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr; + } + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + }, + createDevice: (parent, name, input, output) => { + var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + FS.registerDevice(dev, { + open: (stream) => { + stream.seekable = false; + }, + close: (stream) => { + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, + read: (stream, buffer, offset, length, pos) => { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset + i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, + write: (stream, buffer, offset, length, pos) => { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset + i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }, + }); + return FS.mkdev(path, mode, dev); + }, + forceLoadFile: (obj) => { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest != "undefined") { + throw new Error( + "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.", + ); + } else if (read_) { + try { + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error("Cannot load without read() or XMLHttpRequest."); + } + }, + createLazyFile: (parent, name, url, canRead, canWrite) => { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; + } + LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { + if (idx > this.length - 1 || idx < 0) { + return undefined; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = (idx / this.chunkSize) | 0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + var xhr = new XMLHttpRequest(); + xhr.open("HEAD", url, false); + xhr.send(null); + if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304)) + throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = + (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + var chunkSize = 1024 * 1024; + if (!hasByteServing) chunkSize = datalength; + var doXHR = (from, to) => { + if (from > to) + throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength - 1) + throw new Error("only " + datalength + " bytes available! programmer error!"); + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + xhr.responseType = "arraybuffer"; + if (xhr.overrideMimeType) { + xhr.overrideMimeType("text/plain; charset=x-user-defined"); + } + xhr.send(null); + if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304)) + throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(xhr.response || []); + } + return intArrayFromString(xhr.responseText || "", true); + }; + + this.setDataGetter((chunkNum) => { + var start = chunkNum * chunkSize; + var end = (chunkNum + 1) * chunkSize - 1; + end = Math.min(end, datalength - 1); + if (typeof this.chunks[chunkNum] == "undefined") { + this.chunks[chunkNum] = doXHR(start, end); + } + if (typeof this.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!"); + return this.chunks[chunkNum]; + }); + if (usesGzip || !datalength) { + chunkSize = datalength = 1; + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest != "undefined") { + if (!ENVIRONMENT_IS_WORKER) + throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc"; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, { + length: { + get: function () { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + }, + }, + chunkSize: { + get: function () { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + }, + }, + }); + var properties = { isDevice: false, contents: lazyArray }; + } else { + var properties = { isDevice: false, url: url }; + } + var node = FS.createFile(parent, name, properties, canRead, canWrite); + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + Object.defineProperties(node, { + usedBytes: { + get: function () { + return this.contents.length; + }, + }, + }); + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach((key) => { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + function writeChunks(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= contents.length) return 0; + var size = Math.min(contents.length - position, length); + assert(size >= 0); + if (contents.slice) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents.get(position + i); + } + } + return size; + } + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + return writeChunks(stream, buffer, offset, length, position); + }; + stream_ops.mmap = (stream, length, position, prot, flags) => { + FS.forceLoadFile(node); + var ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + writeChunks(stream, HEAP8, ptr, length, position); + return { ptr: ptr, allocated: true }; + }; + node.stream_ops = stream_ops; + return node; + }, + createPreloadedFile: ( + parent, + name, + url, + canRead, + canWrite, + onload, + onerror, + dontCreateFile, + canOwn, + preFinish, + ) => { + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency("cp " + fullname); + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); + } + if (onload) onload(); + removeRunDependency(dep); + } + if ( + Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => { + if (onerror) onerror(); + removeRunDependency(dep); + }) + ) { + return; + } + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == "string") { + asyncLoad(url, (byteArray) => processData(byteArray), onerror); + } else { + processData(url); + } + }, + indexedDB: () => { + return ( + window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB + ); + }, + DB_NAME: () => { + return "EM_FS_" + window.location.pathname; + }, + DB_VERSION: 20, + DB_STORE_NAME: "FILE_DATA", + saveFilesToDB: (paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = () => { + out("creating db"); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + openRequest.onsuccess = () => { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite"); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, + fail = 0, + total = paths.length; + function finish() { + if (fail == 0) onload(); + else onerror(); + } + paths.forEach((path) => { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = () => { + ok++; + if (ok + fail == total) finish(); + }; + putRequest.onerror = () => { + fail++; + if (ok + fail == total) finish(); + }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }, + loadFilesFromDB: (paths, onload, onerror) => { + onload = onload || (() => {}); + onerror = onerror || (() => {}); + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; + openRequest.onsuccess = () => { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], "readonly"); + } catch (e) { + onerror(e); + return; + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, + fail = 0, + total = paths.length; + function finish() { + if (fail == 0) onload(); + else onerror(); + } + paths.forEach((path) => { + var getRequest = files.get(path); + getRequest.onsuccess = () => { + if (FS.analyzePath(path).exists) { + FS.unlink(path); + } + FS.createDataFile( + PATH.dirname(path), + PATH.basename(path), + getRequest.result, + true, + true, + true, + ); + ok++; + if (ok + fail == total) finish(); + }; + getRequest.onerror = () => { + fail++; + if (ok + fail == total) finish(); + }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }, + absolutePath: () => { + abort("FS.absolutePath has been removed; use PATH_FS.resolve instead"); + }, + createFolder: () => { + abort("FS.createFolder has been removed; use FS.mkdir instead"); + }, + createLink: () => { + abort("FS.createLink has been removed; use FS.symlink instead"); + }, + joinPath: () => { + abort("FS.joinPath has been removed; use PATH.join instead"); + }, + mmapAlloc: () => { + abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc"); + }, + standardizePath: () => { + abort("FS.standardizePath has been removed; use PATH.normalize instead"); + }, + }; + var SYSCALLS = { + DEFAULT_POLLMASK: 5, + calculateAt: function (dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path; + } + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = SYSCALLS.getStreamFromFD(dirfd); + dir = dirstream.path; + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44); + } + return dir; + } + return PATH.join2(dir, path); + }, + doStat: function (func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + return -54; + } + throw e; + } + HEAP32[buf >> 2] = stat.dev; + HEAP32[(buf + 8) >> 2] = stat.ino; + HEAP32[(buf + 12) >> 2] = stat.mode; + HEAPU32[(buf + 16) >> 2] = stat.nlink; + HEAP32[(buf + 20) >> 2] = stat.uid; + HEAP32[(buf + 24) >> 2] = stat.gid; + HEAP32[(buf + 28) >> 2] = stat.rdev; + (tempI64 = [ + stat.size >>> 0, + ((tempDouble = stat.size), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 40) >> 2] = tempI64[0]), + (HEAP32[(buf + 44) >> 2] = tempI64[1]); + HEAP32[(buf + 48) >> 2] = 4096; + HEAP32[(buf + 52) >> 2] = stat.blocks; + (tempI64 = [ + Math.floor(stat.atime.getTime() / 1e3) >>> 0, + ((tempDouble = Math.floor(stat.atime.getTime() / 1e3)), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 56) >> 2] = tempI64[0]), + (HEAP32[(buf + 60) >> 2] = tempI64[1]); + HEAPU32[(buf + 64) >> 2] = 0; + (tempI64 = [ + Math.floor(stat.mtime.getTime() / 1e3) >>> 0, + ((tempDouble = Math.floor(stat.mtime.getTime() / 1e3)), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 72) >> 2] = tempI64[0]), + (HEAP32[(buf + 76) >> 2] = tempI64[1]); + HEAPU32[(buf + 80) >> 2] = 0; + (tempI64 = [ + Math.floor(stat.ctime.getTime() / 1e3) >>> 0, + ((tempDouble = Math.floor(stat.ctime.getTime() / 1e3)), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 88) >> 2] = tempI64[0]), + (HEAP32[(buf + 92) >> 2] = tempI64[1]); + HEAPU32[(buf + 96) >> 2] = 0; + (tempI64 = [ + stat.ino >>> 0, + ((tempDouble = stat.ino), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[(buf + 104) >> 2] = tempI64[0]), + (HEAP32[(buf + 108) >> 2] = tempI64[1]); + return 0; + }, + doMsync: function (addr, stream, len, flags, offset) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (flags & 2) { + return 0; + } + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags); + }, + varargs: undefined, + get: function () { + assert(SYSCALLS.varargs != undefined); + SYSCALLS.varargs += 4; + var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2]; + return ret; + }, + getStr: function (ptr) { + var ret = UTF8ToString(ptr); + return ret; + }, + getStreamFromFD: function (fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream; + }, + }; + function _proc_exit(code) { + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + if (Module["onExit"]) Module["onExit"](code); + ABORT = true; + } + quit_(code, new ExitStatus(code)); + } + function exitJS(status, implicit) { + EXITSTATUS = status; + checkUnflushedContent(); + if (keepRuntimeAlive() && !implicit) { + var msg = + "program exited (with status: " + + status + + "), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)"; + readyPromiseReject(msg); + err(msg); + } + _proc_exit(status); + } + var _exit = exitJS; + function handleException(e) { + if (e instanceof ExitStatus || e == "unwind") { + return EXITSTATUS; + } + checkStackCookie(); + if (e instanceof WebAssembly.RuntimeError) { + if (_emscripten_stack_get_current() <= 0) { + err( + "Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to " + + STACK_SIZE + + ")", + ); + } + } + quit_(1, e); + } + function maybeExit() {} + function setMainLoop(browserIterationFunc, fps, simulateInfiniteLoop, arg, noSetTiming) { + assert( + !Browser.mainLoop.func, + "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.", + ); + Browser.mainLoop.func = browserIterationFunc; + Browser.mainLoop.arg = arg; + var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop; + function checkIsRunning() { + if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) { + maybeExit(); + return false; + } + return true; + } + Browser.mainLoop.running = false; + Browser.mainLoop.runner = function Browser_mainLoop_runner() { + if (ABORT) return; + if (Browser.mainLoop.queue.length > 0) { + var start = Date.now(); + var blocker = Browser.mainLoop.queue.shift(); + blocker.func(blocker.arg); + if (Browser.mainLoop.remainingBlockers) { + var remaining = Browser.mainLoop.remainingBlockers; + var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining); + if (blocker.counted) { + Browser.mainLoop.remainingBlockers = next; + } else { + next = next + 0.5; + Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9; + } + } + out('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + " ms"); + Browser.mainLoop.updateStatus(); + if (!checkIsRunning()) return; + setTimeout(Browser.mainLoop.runner, 0); + return; + } + if (!checkIsRunning()) return; + Browser.mainLoop.currentFrameNumber = (Browser.mainLoop.currentFrameNumber + 1) | 0; + if ( + Browser.mainLoop.timingMode == 1 && + Browser.mainLoop.timingValue > 1 && + Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0 + ) { + Browser.mainLoop.scheduler(); + return; + } else if (Browser.mainLoop.timingMode == 0) { + Browser.mainLoop.tickStartTime = _emscripten_get_now(); + } + GL.newRenderingFrameStarted(); + if ( + typeof GL != "undefined" && + GL.currentContext && + !GL.currentContextIsProxied && + !GL.currentContext.attributes.explicitSwapControl && + GL.currentContext.GLctx.commit + ) { + GL.currentContext.GLctx.commit(); + } + if (Browser.mainLoop.method === "timeout" && Module.ctx) { + warnOnce( + "Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!", + ); + Browser.mainLoop.method = ""; + } + Browser.mainLoop.runIter(browserIterationFunc); + checkStackCookie(); + if (!checkIsRunning()) return; + if (typeof SDL == "object" && SDL.audio && SDL.audio.queueNewAudioData) + SDL.audio.queueNewAudioData(); + Browser.mainLoop.scheduler(); + }; + if (!noSetTiming) { + if (fps && fps > 0) _emscripten_set_main_loop_timing(0, 1e3 / fps); + else _emscripten_set_main_loop_timing(1, 1); + Browser.mainLoop.scheduler(); + } + if (simulateInfiniteLoop) { + throw "unwind"; + } + } + function callUserCallback(func) { + if (ABORT) { + err("user callback triggered after runtime exited or application aborted. Ignoring."); + return; + } + try { + func(); + } catch (e) { + handleException(e); + } + } + function safeSetTimeout(func, timeout) { + return setTimeout(function () { + callUserCallback(func); + }, timeout); + } + function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + if (ENVIRONMENT_IS_NODE) text = "warning: " + text; + err(text); + } + } + var Browser = { + mainLoop: { + running: false, + scheduler: null, + method: "", + currentlyRunningMainloop: 0, + func: null, + arg: 0, + timingMode: 0, + timingValue: 0, + currentFrameNumber: 0, + queue: [], + pause: function () { + Browser.mainLoop.scheduler = null; + Browser.mainLoop.currentlyRunningMainloop++; + }, + resume: function () { + Browser.mainLoop.currentlyRunningMainloop++; + var timingMode = Browser.mainLoop.timingMode; + var timingValue = Browser.mainLoop.timingValue; + var func = Browser.mainLoop.func; + Browser.mainLoop.func = null; + setMainLoop(func, 0, false, Browser.mainLoop.arg, true); + _emscripten_set_main_loop_timing(timingMode, timingValue); + Browser.mainLoop.scheduler(); + }, + updateStatus: function () { + if (Module["setStatus"]) { + var message = Module["statusMessage"] || "Please wait..."; + var remaining = Browser.mainLoop.remainingBlockers; + var expected = Browser.mainLoop.expectedBlockers; + if (remaining) { + if (remaining < expected) { + Module["setStatus"](message + " (" + (expected - remaining) + "/" + expected + ")"); + } else { + Module["setStatus"](message); + } + } else { + Module["setStatus"](""); + } + } + }, + runIter: function (func) { + if (ABORT) return; + if (Module["preMainLoop"]) { + var preRet = Module["preMainLoop"](); + if (preRet === false) { + return; + } + } + callUserCallback(func); + if (Module["postMainLoop"]) Module["postMainLoop"](); + }, + }, + isFullscreen: false, + pointerLock: false, + moduleContextCreatedCallbacks: [], + workers: [], + init: function () { + if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; + if (Browser.initted) return; + Browser.initted = true; + try { + new Blob(); + Browser.hasBlobConstructor = true; + } catch (e) { + Browser.hasBlobConstructor = false; + err("warning: no blob constructor, cannot create blobs with mimetypes"); + } + Browser.BlobBuilder = + typeof MozBlobBuilder != "undefined" + ? MozBlobBuilder + : typeof WebKitBlobBuilder != "undefined" + ? WebKitBlobBuilder + : !Browser.hasBlobConstructor + ? err("warning: no BlobBuilder") + : null; + Browser.URLObject = + typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined; + if (!Module.noImageDecoding && typeof Browser.URLObject == "undefined") { + err( + "warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.", + ); + Module.noImageDecoding = true; + } + var imagePlugin = {}; + imagePlugin["canHandle"] = function imagePlugin_canHandle(name) { + return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name); + }; + imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) { + var b = null; + if (Browser.hasBlobConstructor) { + try { + b = new Blob([byteArray], { type: Browser.getMimetype(name) }); + if (b.size !== byteArray.length) { + b = new Blob([new Uint8Array(byteArray).buffer], { + type: Browser.getMimetype(name), + }); + } + } catch (e) { + warnOnce( + "Blob constructor present but fails: " + e + "; falling back to blob builder", + ); + } + } + if (!b) { + var bb = new Browser.BlobBuilder(); + bb.append(new Uint8Array(byteArray).buffer); + b = bb.getBlob(); + } + var url = Browser.URLObject.createObjectURL(b); + assert(typeof url == "string", "createObjectURL must return a url as a string"); + var img = new Image(); + img.onload = () => { + assert(img.complete, "Image " + name + " could not be decoded"); + var canvas = document.createElement("canvas"); + canvas.width = img.width; + canvas.height = img.height; + var ctx = canvas.getContext("2d"); + ctx.drawImage(img, 0, 0); + preloadedImages[name] = canvas; + Browser.URLObject.revokeObjectURL(url); + if (onload) onload(byteArray); + }; + img.onerror = (event) => { + out("Image " + url + " could not be decoded"); + if (onerror) onerror(); + }; + img.src = url; + }; + Module["preloadPlugins"].push(imagePlugin); + var audioPlugin = {}; + audioPlugin["canHandle"] = function audioPlugin_canHandle(name) { + return !Module.noAudioDecoding && name.substr(-4) in { ".ogg": 1, ".wav": 1, ".mp3": 1 }; + }; + audioPlugin["handle"] = function audioPlugin_handle(byteArray, name, onload, onerror) { + var done = false; + function finish(audio) { + if (done) return; + done = true; + preloadedAudios[name] = audio; + if (onload) onload(byteArray); + } + function fail() { + if (done) return; + done = true; + preloadedAudios[name] = new Audio(); + if (onerror) onerror(); + } + if (Browser.hasBlobConstructor) { + try { + var b = new Blob([byteArray], { type: Browser.getMimetype(name) }); + } catch (e) { + return fail(); + } + var url = Browser.URLObject.createObjectURL(b); + assert(typeof url == "string", "createObjectURL must return a url as a string"); + var audio = new Audio(); + audio.addEventListener("canplaythrough", () => finish(audio), false); + audio.onerror = function audio_onerror(event) { + if (done) return; + err( + "warning: browser could not fully decode audio " + + name + + ", trying slower base64 approach", + ); + function encode64(data) { + var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var PAD = "="; + var ret = ""; + var leftchar = 0; + var leftbits = 0; + for (var i = 0; i < data.length; i++) { + leftchar = (leftchar << 8) | data[i]; + leftbits += 8; + while (leftbits >= 6) { + var curr = (leftchar >> (leftbits - 6)) & 63; + leftbits -= 6; + ret += BASE[curr]; + } + } + if (leftbits == 2) { + ret += BASE[(leftchar & 3) << 4]; + ret += PAD + PAD; + } else if (leftbits == 4) { + ret += BASE[(leftchar & 15) << 2]; + ret += PAD; + } + return ret; + } + audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray); + finish(audio); + }; + audio.src = url; + safeSetTimeout(function () { + finish(audio); + }, 1e4); + } else { + return fail(); + } + }; + Module["preloadPlugins"].push(audioPlugin); + function pointerLockChange() { + Browser.pointerLock = + document["pointerLockElement"] === Module["canvas"] || + document["mozPointerLockElement"] === Module["canvas"] || + document["webkitPointerLockElement"] === Module["canvas"] || + document["msPointerLockElement"] === Module["canvas"]; + } + var canvas = Module["canvas"]; + if (canvas) { + canvas.requestPointerLock = + canvas["requestPointerLock"] || + canvas["mozRequestPointerLock"] || + canvas["webkitRequestPointerLock"] || + canvas["msRequestPointerLock"] || + (() => {}); + canvas.exitPointerLock = + document["exitPointerLock"] || + document["mozExitPointerLock"] || + document["webkitExitPointerLock"] || + document["msExitPointerLock"] || + (() => {}); + canvas.exitPointerLock = canvas.exitPointerLock.bind(document); + document.addEventListener("pointerlockchange", pointerLockChange, false); + document.addEventListener("mozpointerlockchange", pointerLockChange, false); + document.addEventListener("webkitpointerlockchange", pointerLockChange, false); + document.addEventListener("mspointerlockchange", pointerLockChange, false); + if (Module["elementPointerLock"]) { + canvas.addEventListener( + "click", + (ev) => { + if (!Browser.pointerLock && Module["canvas"].requestPointerLock) { + Module["canvas"].requestPointerLock(); + ev.preventDefault(); + } + }, + false, + ); + } + } + }, + handledByPreloadPlugin: function (byteArray, fullname, finish, onerror) { + Browser.init(); + var handled = false; + Module["preloadPlugins"].forEach(function (plugin) { + if (handled) return; + if (plugin["canHandle"](fullname)) { + plugin["handle"](byteArray, fullname, finish, onerror); + handled = true; + } + }); + return handled; + }, + createContext: function (canvas, useWebGL, setInModule, webGLContextAttributes) { + if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx; + var ctx; + var contextHandle; + if (useWebGL) { + var contextAttributes = { + antialias: false, + alpha: false, + majorVersion: typeof WebGL2RenderingContext != "undefined" ? 2 : 1, + }; + if (webGLContextAttributes) { + for (var attribute in webGLContextAttributes) { + contextAttributes[attribute] = webGLContextAttributes[attribute]; + } + } + if (typeof GL != "undefined") { + contextHandle = GL.createContext(canvas, contextAttributes); + if (contextHandle) { + ctx = GL.getContext(contextHandle).GLctx; + } + } + } else { + ctx = canvas.getContext("2d"); + } + if (!ctx) return null; + if (setInModule) { + if (!useWebGL) + assert( + typeof GLctx == "undefined", + "cannot set in module if GLctx is used, but we are a non-GL context that would replace it", + ); + Module.ctx = ctx; + if (useWebGL) GL.makeContextCurrent(contextHandle); + Module.useWebGL = useWebGL; + Browser.moduleContextCreatedCallbacks.forEach(function (callback) { + callback(); + }); + Browser.init(); + } + return ctx; + }, + destroyContext: function (canvas, useWebGL, setInModule) {}, + fullscreenHandlersInstalled: false, + lockPointer: undefined, + resizeCanvas: undefined, + requestFullscreen: function (lockPointer, resizeCanvas) { + Browser.lockPointer = lockPointer; + Browser.resizeCanvas = resizeCanvas; + if (typeof Browser.lockPointer == "undefined") Browser.lockPointer = true; + if (typeof Browser.resizeCanvas == "undefined") Browser.resizeCanvas = false; + var canvas = Module["canvas"]; + function fullscreenChange() { + Browser.isFullscreen = false; + var canvasContainer = canvas.parentNode; + if ( + (document["fullscreenElement"] || + document["mozFullScreenElement"] || + document["msFullscreenElement"] || + document["webkitFullscreenElement"] || + document["webkitCurrentFullScreenElement"]) === canvasContainer + ) { + canvas.exitFullscreen = Browser.exitFullscreen; + if (Browser.lockPointer) canvas.requestPointerLock(); + Browser.isFullscreen = true; + if (Browser.resizeCanvas) { + Browser.setFullscreenCanvasSize(); + } else { + Browser.updateCanvasDimensions(canvas); + } + } else { + canvasContainer.parentNode.insertBefore(canvas, canvasContainer); + canvasContainer.parentNode.removeChild(canvasContainer); + if (Browser.resizeCanvas) { + Browser.setWindowedCanvasSize(); + } else { + Browser.updateCanvasDimensions(canvas); + } + } + if (Module["onFullScreen"]) Module["onFullScreen"](Browser.isFullscreen); + if (Module["onFullscreen"]) Module["onFullscreen"](Browser.isFullscreen); + } + if (!Browser.fullscreenHandlersInstalled) { + Browser.fullscreenHandlersInstalled = true; + document.addEventListener("fullscreenchange", fullscreenChange, false); + document.addEventListener("mozfullscreenchange", fullscreenChange, false); + document.addEventListener("webkitfullscreenchange", fullscreenChange, false); + document.addEventListener("MSFullscreenChange", fullscreenChange, false); + } + var canvasContainer = document.createElement("div"); + canvas.parentNode.insertBefore(canvasContainer, canvas); + canvasContainer.appendChild(canvas); + canvasContainer.requestFullscreen = + canvasContainer["requestFullscreen"] || + canvasContainer["mozRequestFullScreen"] || + canvasContainer["msRequestFullscreen"] || + (canvasContainer["webkitRequestFullscreen"] + ? () => canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]) + : null) || + (canvasContainer["webkitRequestFullScreen"] + ? () => canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]) + : null); + canvasContainer.requestFullscreen(); + }, + requestFullScreen: function () { + abort( + "Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)", + ); + }, + exitFullscreen: function () { + if (!Browser.isFullscreen) { + return false; + } + var CFS = + document["exitFullscreen"] || + document["cancelFullScreen"] || + document["mozCancelFullScreen"] || + document["msExitFullscreen"] || + document["webkitCancelFullScreen"] || + function () {}; + CFS.apply(document, []); + return true; + }, + nextRAF: 0, + fakeRequestAnimationFrame: function (func) { + var now = Date.now(); + if (Browser.nextRAF === 0) { + Browser.nextRAF = now + 1e3 / 60; + } else { + while (now + 2 >= Browser.nextRAF) { + Browser.nextRAF += 1e3 / 60; + } + } + var delay = Math.max(Browser.nextRAF - now, 0); + setTimeout(func, delay); + }, + requestAnimationFrame: function (func) { + if (typeof requestAnimationFrame == "function") { + requestAnimationFrame(func); + return; + } + var RAF = Browser.fakeRequestAnimationFrame; + RAF(func); + }, + safeSetTimeout: function (func, timeout) { + return safeSetTimeout(func, timeout); + }, + safeRequestAnimationFrame: function (func) { + return Browser.requestAnimationFrame(function () { + callUserCallback(func); + }); + }, + getMimetype: function (name) { + return { + jpg: "image/jpeg", + jpeg: "image/jpeg", + png: "image/png", + bmp: "image/bmp", + ogg: "audio/ogg", + wav: "audio/wav", + mp3: "audio/mpeg", + }[name.substr(name.lastIndexOf(".") + 1)]; + }, + getUserMedia: function (func) { + if (!window.getUserMedia) { + window.getUserMedia = navigator["getUserMedia"] || navigator["mozGetUserMedia"]; + } + window.getUserMedia(func); + }, + getMovementX: function (event) { + return event["movementX"] || event["mozMovementX"] || event["webkitMovementX"] || 0; + }, + getMovementY: function (event) { + return event["movementY"] || event["mozMovementY"] || event["webkitMovementY"] || 0; + }, + getMouseWheelDelta: function (event) { + var delta = 0; + switch (event.type) { + case "DOMMouseScroll": + delta = event.detail / 3; + break; + case "mousewheel": + delta = event.wheelDelta / 120; + break; + case "wheel": + delta = event.deltaY; + switch (event.deltaMode) { + case 0: + delta /= 100; + break; + case 1: + delta /= 3; + break; + case 2: + delta *= 80; + break; + default: + throw "unrecognized mouse wheel delta mode: " + event.deltaMode; + } + break; + default: + throw "unrecognized mouse wheel event: " + event.type; + } + return delta; + }, + mouseX: 0, + mouseY: 0, + mouseMovementX: 0, + mouseMovementY: 0, + touches: {}, + lastTouches: {}, + calculateMouseEvent: function (event) { + if (Browser.pointerLock) { + if (event.type != "mousemove" && "mozMovementX" in event) { + Browser.mouseMovementX = Browser.mouseMovementY = 0; + } else { + Browser.mouseMovementX = Browser.getMovementX(event); + Browser.mouseMovementY = Browser.getMovementY(event); + } + if (typeof SDL != "undefined") { + Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; + Browser.mouseY = SDL.mouseY + Browser.mouseMovementY; + } else { + Browser.mouseX += Browser.mouseMovementX; + Browser.mouseY += Browser.mouseMovementY; + } + } else { + var rect = Module["canvas"].getBoundingClientRect(); + var cw = Module["canvas"].width; + var ch = Module["canvas"].height; + var scrollX = typeof window.scrollX != "undefined" ? window.scrollX : window.pageXOffset; + var scrollY = typeof window.scrollY != "undefined" ? window.scrollY : window.pageYOffset; + assert( + typeof scrollX != "undefined" && typeof scrollY != "undefined", + "Unable to retrieve scroll position, mouse positions likely broken.", + ); + if ( + event.type === "touchstart" || + event.type === "touchend" || + event.type === "touchmove" + ) { + var touch = event.touch; + if (touch === undefined) { + return; + } + var adjustedX = touch.pageX - (scrollX + rect.left); + var adjustedY = touch.pageY - (scrollY + rect.top); + adjustedX = adjustedX * (cw / rect.width); + adjustedY = adjustedY * (ch / rect.height); + var coords = { x: adjustedX, y: adjustedY }; + if (event.type === "touchstart") { + Browser.lastTouches[touch.identifier] = coords; + Browser.touches[touch.identifier] = coords; + } else if (event.type === "touchend" || event.type === "touchmove") { + var last = Browser.touches[touch.identifier]; + if (!last) last = coords; + Browser.lastTouches[touch.identifier] = last; + Browser.touches[touch.identifier] = coords; + } + return; + } + var x = event.pageX - (scrollX + rect.left); + var y = event.pageY - (scrollY + rect.top); + x = x * (cw / rect.width); + y = y * (ch / rect.height); + Browser.mouseMovementX = x - Browser.mouseX; + Browser.mouseMovementY = y - Browser.mouseY; + Browser.mouseX = x; + Browser.mouseY = y; + } + }, + resizeListeners: [], + updateResizeListeners: function () { + var canvas = Module["canvas"]; + Browser.resizeListeners.forEach(function (listener) { + listener(canvas.width, canvas.height); + }); + }, + setCanvasSize: function (width, height, noUpdates) { + var canvas = Module["canvas"]; + Browser.updateCanvasDimensions(canvas, width, height); + if (!noUpdates) Browser.updateResizeListeners(); + }, + windowedWidth: 0, + windowedHeight: 0, + setFullscreenCanvasSize: function () { + if (typeof SDL != "undefined") { + var flags = HEAPU32[SDL.screen >> 2]; + flags = flags | 8388608; + HEAP32[SDL.screen >> 2] = flags; + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners(); + }, + setWindowedCanvasSize: function () { + if (typeof SDL != "undefined") { + var flags = HEAPU32[SDL.screen >> 2]; + flags = flags & ~8388608; + HEAP32[SDL.screen >> 2] = flags; + } + Browser.updateCanvasDimensions(Module["canvas"]); + Browser.updateResizeListeners(); + }, + updateCanvasDimensions: function (canvas, wNative, hNative) { + if (wNative && hNative) { + canvas.widthNative = wNative; + canvas.heightNative = hNative; + } else { + wNative = canvas.widthNative; + hNative = canvas.heightNative; + } + var w = wNative; + var h = hNative; + if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) { + if (w / h < Module["forcedAspectRatio"]) { + w = Math.round(h * Module["forcedAspectRatio"]); + } else { + h = Math.round(w / Module["forcedAspectRatio"]); + } + } + if ( + (document["fullscreenElement"] || + document["mozFullScreenElement"] || + document["msFullscreenElement"] || + document["webkitFullscreenElement"] || + document["webkitCurrentFullScreenElement"]) === canvas.parentNode && + typeof screen != "undefined" + ) { + var factor = Math.min(screen.width / w, screen.height / h); + w = Math.round(w * factor); + h = Math.round(h * factor); + } + if (Browser.resizeCanvas) { + if (canvas.width != w) canvas.width = w; + if (canvas.height != h) canvas.height = h; + if (typeof canvas.style != "undefined") { + canvas.style.removeProperty("width"); + canvas.style.removeProperty("height"); + } + } else { + if (canvas.width != wNative) canvas.width = wNative; + if (canvas.height != hNative) canvas.height = hNative; + if (typeof canvas.style != "undefined") { + if (w != wNative || h != hNative) { + canvas.style.setProperty("width", w + "px", "important"); + canvas.style.setProperty("height", h + "px", "important"); + } else { + canvas.style.removeProperty("width"); + canvas.style.removeProperty("height"); + } + } + } + }, + }; + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + callbacks.shift()(Module); + } + } + function ptrToString(ptr) { + return "0x" + ptr.toString(16).padStart(8, "0"); + } + function ___assert_fail(condition, filename, line, func) { + abort( + "Assertion failed: " + + UTF8ToString(condition) + + ", at: " + + [ + filename ? UTF8ToString(filename) : "unknown filename", + line, + func ? UTF8ToString(func) : "unknown function", + ], + ); + } + function ___cxa_allocate_exception(size) { + return _malloc(size + 24) + 24; + } + function ExceptionInfo(excPtr) { + this.excPtr = excPtr; + this.ptr = excPtr - 24; + this.set_type = function (type) { + HEAPU32[(this.ptr + 4) >> 2] = type; + }; + this.get_type = function () { + return HEAPU32[(this.ptr + 4) >> 2]; + }; + this.set_destructor = function (destructor) { + HEAPU32[(this.ptr + 8) >> 2] = destructor; + }; + this.get_destructor = function () { + return HEAPU32[(this.ptr + 8) >> 2]; + }; + this.set_refcount = function (refcount) { + HEAP32[this.ptr >> 2] = refcount; + }; + this.set_caught = function (caught) { + caught = caught ? 1 : 0; + HEAP8[(this.ptr + 12) >> 0] = caught; + }; + this.get_caught = function () { + return HEAP8[(this.ptr + 12) >> 0] != 0; + }; + this.set_rethrown = function (rethrown) { + rethrown = rethrown ? 1 : 0; + HEAP8[(this.ptr + 13) >> 0] = rethrown; + }; + this.get_rethrown = function () { + return HEAP8[(this.ptr + 13) >> 0] != 0; + }; + this.init = function (type, destructor) { + this.set_adjusted_ptr(0); + this.set_type(type); + this.set_destructor(destructor); + this.set_refcount(0); + this.set_caught(false); + this.set_rethrown(false); + }; + this.add_ref = function () { + var value = HEAP32[this.ptr >> 2]; + HEAP32[this.ptr >> 2] = value + 1; + }; + this.release_ref = function () { + var prev = HEAP32[this.ptr >> 2]; + HEAP32[this.ptr >> 2] = prev - 1; + assert(prev > 0); + return prev === 1; + }; + this.set_adjusted_ptr = function (adjustedPtr) { + HEAPU32[(this.ptr + 16) >> 2] = adjustedPtr; + }; + this.get_adjusted_ptr = function () { + return HEAPU32[(this.ptr + 16) >> 2]; + }; + this.get_exception_ptr = function () { + var isPointer = ___cxa_is_pointer_type(this.get_type()); + if (isPointer) { + return HEAPU32[this.excPtr >> 2]; + } + var adjusted = this.get_adjusted_ptr(); + if (adjusted !== 0) return adjusted; + return this.excPtr; + }; + } + var exceptionLast = 0; + var uncaughtExceptionCount = 0; + function ___cxa_throw(ptr, type, destructor) { + var info = new ExceptionInfo(ptr); + info.init(type, destructor); + exceptionLast = ptr; + uncaughtExceptionCount++; + throw ( + ptr + + " - Exception catching is disabled, this exception cannot be caught. Compile with -sNO_DISABLE_EXCEPTION_CATCHING or -sEXCEPTION_CATCHING_ALLOWED=[..] to catch." + ); + } + function ___syscall_dup(fd) { + try { + var old = SYSCALLS.getStreamFromFD(fd); + return FS.createStream(old, 0).fd; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function setErrNo(value) { + HEAP32[___errno_location() >> 2] = value; + return value; + } + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.createStream(stream, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 5: { + var arg = SYSCALLS.get(); + var offset = 0; + HEAP16[(arg + offset) >> 1] = 2; + return 0; + } + case 6: + case 7: + return 0; + case 16: + case 8: + return -28; + case 9: + setErrNo(28); + return -1; + default: { + return -28; + } + } + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_fstat64(fd, buf) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: { + if (!stream.tty) return -59; + return 0; + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: { + if (!stream.tty) return -59; + return 0; + } + case 21519: { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + HEAP32[argp >> 2] = 0; + return 0; + } + case 21520: { + if (!stream.tty) return -59; + return -28; + } + case 21531: { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + case 21523: { + if (!stream.tty) return -59; + return 0; + } + case 21524: { + if (!stream.tty) return -59; + return 0; + } + default: + return -28; + } + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_lstat64(path, buf) { + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_newfstatat(dirfd, path, buf, flags) { + try { + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & ~6400; + assert(!flags, "unknown flags in __syscall_newfstatat: " + flags); + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? SYSCALLS.get() : 0; + return FS.open(path, flags, mode).fd; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function ___syscall_stat64(path, buf) { + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function __dlinit(main_dso_handle) {} + var dlopenMissingError = + "To use dlopen, you need enable dynamic linking, see https://github.com/emscripten-core/emscripten/wiki/Linking"; + function __dlopen_js(filename, flag) { + abort(dlopenMissingError); + } + function __dlsym_js(handle, symbol) { + abort(dlopenMissingError); + } + var char_0 = 48; + var char_9 = 57; + function makeLegalFunctionName(name) { + if (undefined === name) { + return "_unknown"; + } + name = name.replace(/[^a-zA-Z0-9_]/g, "$"); + var f = name.charCodeAt(0); + if (f >= char_0 && f <= char_9) { + return "_" + name; + } + return name; + } + function createNamedFunction(name, body) { + name = makeLegalFunctionName(name); + return function () { + "use strict"; + return body.apply(this, arguments); + }; + } + var emval_handle_array = [ + {}, + { value: undefined }, + { value: null }, + { value: true }, + { value: false }, + ]; + var emval_free_list = []; + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function (message) { + this.name = errorName; + this.message = message; + var stack = new Error(message).stack; + if (stack !== undefined) { + this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, ""); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function () { + if (this.message === undefined) { + return this.name; + } else { + return this.name + ": " + this.message; + } + }; + return errorClass; + } + var BindingError = undefined; + function throwBindingError(message) { + throw new BindingError(message); + } + function count_emval_handles() { + var count = 0; + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + ++count; + } + } + return count; + } + function get_first_emval() { + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== undefined) { + return emval_handle_array[i]; + } + } + return null; + } + function init_emval() { + Module["count_emval_handles"] = count_emval_handles; + Module["get_first_emval"] = get_first_emval; + } + var Emval = { + toValue: (handle) => { + if (!handle) { + throwBindingError("Cannot use deleted val. handle = " + handle); + } + return emval_handle_array[handle].value; + }, + toHandle: (value) => { + switch (value) { + case undefined: + return 1; + case null: + return 2; + case true: + return 3; + case false: + return 4; + default: { + var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length; + emval_handle_array[handle] = { refcount: 1, value: value }; + return handle; + } + } + }, + }; + var PureVirtualError = undefined; + function embind_init_charCodes() { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + } + var embind_charCodes = undefined; + function readLatin1String(ptr) { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + } + function getInheritedInstanceCount() { + return Object.keys(registeredInstances).length; + } + function getLiveInheritedInstances() { + var rv = []; + for (var k in registeredInstances) { + if (Object.hasOwn(registeredInstances, k)) { + rv.push(registeredInstances[k]); + } + } + return rv; + } + var deletionQueue = []; + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj["delete"](); + } + } + var delayFunction = undefined; + function setDelayFunction(fn) { + delayFunction = fn; + if (deletionQueue.length && delayFunction) { + delayFunction(flushPendingDeletes); + } + } + function init_embind() { + Module["getInheritedInstanceCount"] = getInheritedInstanceCount; + Module["getLiveInheritedInstances"] = getLiveInheritedInstances; + Module["flushPendingDeletes"] = flushPendingDeletes; + Module["setDelayFunction"] = setDelayFunction; + } + var registeredInstances = {}; + function getBasestPointer(class_, ptr) { + if (ptr === undefined) { + throwBindingError("ptr should not be undefined"); + } + while (class_.baseClass) { + ptr = class_.upcast(ptr); + class_ = class_.baseClass; + } + return ptr; + } + function registerInheritedInstance(class_, ptr, instance) { + ptr = getBasestPointer(class_, ptr); + if (Object.hasOwn(registeredInstances, ptr)) { + throwBindingError("Tried to register registered instance: " + ptr); + } else { + registeredInstances[ptr] = instance; + } + } + var registeredTypes = {}; + function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; + } + function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); + } + return impl; + } + function unregisterInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + if (Object.hasOwn(registeredInstances, ptr)) { + delete registeredInstances[ptr]; + } else { + throwBindingError("Tried to unregister unregistered instance: " + ptr); + } + } + function detachFinalizer(handle) {} + var finalizationRegistry = false; + function runDestructor($$) { + if ($$.smartPtr) { + $$.smartPtrType.rawDestructor($$.smartPtr); + } else { + $$.ptrType.registeredClass.rawDestructor($$.ptr); + } + } + function releaseClassHandle($$) { + $$.count.value -= 1; + var toDelete = 0 === $$.count.value; + if (toDelete) { + runDestructor($$); + } + } + function downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (undefined === desiredClass.baseClass) { + return null; + } + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); + } + var registeredPointers = {}; + function getInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + return registeredInstances[ptr]; + } + var InternalError = undefined; + function throwInternalError(message) { + throw new InternalError(message); + } + function makeClassHandle(prototype, record) { + if (!record.ptrType || !record.ptr) { + throwInternalError("makeClassHandle requires ptr and ptrType"); + } + var hasSmartPtrType = !!record.smartPtrType; + var hasSmartPtr = !!record.smartPtr; + if (hasSmartPtrType !== hasSmartPtr) { + throwInternalError("Both smartPtrType and smartPtr must be specified"); + } + record.count = { value: 1 }; + return attachFinalizer(Object.create(prototype, { $$: { value: record } })); + } + function RegisteredPointer_fromWireType(ptr) { + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (undefined !== registeredInstance) { + if (0 === registeredInstance.$$.count.value) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance["clone"](); + } else { + var rv = registeredInstance["clone"](); + this.destructor(ptr); + return rv; + } + } + function makeDefaultHandle() { + if (this.isSmartPointer) { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this.pointeeType, + ptr: rawPointer, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(this.registeredClass.instancePrototype, { + ptrType: this, + ptr: ptr, + }); + } + } + var actualType = this.registeredClass.getActualType(rawPointer); + var registeredPointerRecord = registeredPointers[actualType]; + if (!registeredPointerRecord) { + return makeDefaultHandle.call(this); + } + var toType; + if (this.isConst) { + toType = registeredPointerRecord.constPointerType; + } else { + toType = registeredPointerRecord.pointerType; + } + var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass); + if (dp === null) { + return makeDefaultHandle.call(this); + } + if (this.isSmartPointer) { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + smartPtrType: this, + smartPtr: ptr, + }); + } else { + return makeClassHandle(toType.registeredClass.instancePrototype, { + ptrType: toType, + ptr: dp, + }); + } + } + function attachFinalizer(handle) { + if ("undefined" === typeof FinalizationRegistry) { + attachFinalizer = (handle) => handle; + return handle; + } + finalizationRegistry = new FinalizationRegistry((info) => { + console.warn(info.leakWarning.stack.replace(/^Error: /, "")); + releaseClassHandle(info.$$); + }); + attachFinalizer = (handle) => { + var $$ = handle.$$; + var hasSmartPtr = !!$$.smartPtr; + if (hasSmartPtr) { + var info = { $$: $$ }; + var cls = $$.ptrType.registeredClass; + info.leakWarning = new Error( + "Embind found a leaked C++ instance " + + cls.name + + " <" + + ptrToString($$.ptr) + + ">.\n" + + "We'll free it automatically in this case, but this functionality is not reliable across various environments.\n" + + "Make sure to invoke .delete() manually once you're done with the instance instead.\n" + + "Originally allocated", + ); + if ("captureStackTrace" in Error) { + Error.captureStackTrace(info.leakWarning, RegisteredPointer_fromWireType); + } + finalizationRegistry.register(handle, info, handle); + } + return handle; + }; + detachFinalizer = (handle) => finalizationRegistry.unregister(handle); + return attachFinalizer(handle); + } + function __embind_create_inheriting_constructor(constructorName, wrapperType, properties) { + constructorName = readLatin1String(constructorName); + wrapperType = requireRegisteredType(wrapperType, "wrapper"); + properties = Emval.toValue(properties); + var arraySlice = [].slice; + var registeredClass = wrapperType.registeredClass; + var wrapperPrototype = registeredClass.instancePrototype; + var baseClass = registeredClass.baseClass; + var baseClassPrototype = baseClass.instancePrototype; + var baseConstructor = registeredClass.baseClass.constructor; + var ctor = createNamedFunction(constructorName, function () { + registeredClass.baseClass.pureVirtualFunctions.forEach( + function (name) { + if (this[name] === baseClassPrototype[name]) { + throw new PureVirtualError( + "Pure virtual function " + name + " must be implemented in JavaScript", + ); + } + }.bind(this), + ); + Object.defineProperty(this, "__parent", { value: wrapperPrototype }); + this["__construct"].apply(this, arraySlice.call(arguments)); + }); + wrapperPrototype["__construct"] = function __construct() { + if (this === wrapperPrototype) { + throwBindingError("Pass correct 'this' to __construct"); + } + var inner = baseConstructor["implement"].apply( + undefined, + [this].concat(arraySlice.call(arguments)), + ); + detachFinalizer(inner); + var $$ = inner.$$; + inner["notifyOnDestruction"](); + $$.preservePointerOnDelete = true; + Object.defineProperties(this, { $$: { value: $$ } }); + attachFinalizer(this); + registerInheritedInstance(registeredClass, $$.ptr, this); + }; + wrapperPrototype["__destruct"] = function __destruct() { + if (this === wrapperPrototype) { + throwBindingError("Pass correct 'this' to __destruct"); + } + detachFinalizer(this); + unregisterInheritedInstance(registeredClass, this.$$.ptr); + }; + ctor.prototype = Object.create(wrapperPrototype); + for (var p in properties) { + ctor.prototype[p] = properties[p]; + } + return Emval.toHandle(ctor); + } + var structRegistrations = {}; + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + } + function simpleReadValueFromPointer(pointer) { + return this["fromWireType"](HEAP32[pointer >> 2]); + } + var awaitingDependencies = {}; + var typeDependencies = {}; + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function (type) { + typeDependencies[type] = dependentTypes; + }); + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError("Mismatched type converter count"); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (Object.hasOwn(registeredTypes, dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!Object.hasOwn(awaitingDependencies, dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + } + function __embind_finalize_value_object(structType) { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords + .map((field) => field.getterReturnType) + .concat(fieldRecords.map((field) => field.setterArgumentType)); + whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes) => { + var fields = {}; + fieldRecords.forEach((field, i) => { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = { + read: (ptr) => { + return getterReturnType["fromWireType"](getter(getterContext, ptr)); + }, + write: (ptr, o) => { + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o)); + runDestructors(destructors); + }, + }; + }); + return [ + { + name: reg.name, + fromWireType: function (ptr) { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, + toWireType: function (destructors, o) { + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError('Missing field: "' + fieldName + '"'); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, + argPackAdvance: 8, + readValueFromPointer: simpleReadValueFromPointer, + destructorFunction: rawDestructor, + }, + ]; + }); + } + function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {} + function getShiftFromSize(size) { + switch (size) { + case 1: + return 0; + case 2: + return 1; + case 4: + return 2; + case 8: + return 3; + default: + throw new TypeError("Unknown type size: " + size); + } + } + function registerType(rawType, registeredInstance, options = {}) { + if (!("argPackAdvance" in registeredInstance)) { + throw new TypeError("registerType registeredInstance requires argPackAdvance"); + } + var name = registeredInstance.name; + if (!rawType) { + throwBindingError('type "' + name + '" must have a positive integer typeid pointer'); + } + if (Object.hasOwn(registeredTypes, rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError("Cannot register type '" + name + "' twice"); + } + } + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + if (Object.hasOwn(awaitingDependencies, rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach((cb) => cb()); + } + } + function __embind_register_bool(rawType, name, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + fromWireType: function (wt) { + return !!wt; + }, + toWireType: function (destructors, o) { + return o ? trueValue : falseValue; + }, + argPackAdvance: 8, + readValueFromPointer: function (pointer) { + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name); + } + return this["fromWireType"](heap[pointer >> shift]); + }, + destructorFunction: null, + }); + } + function ClassHandle_isAliasOf(other) { + if (!(this instanceof ClassHandle)) { + return false; + } + if (!(other instanceof ClassHandle)) { + return false; + } + var leftClass = this.$$.ptrType.registeredClass; + var left = this.$$.ptr; + var rightClass = other.$$.ptrType.registeredClass; + var right = other.$$.ptr; + while (leftClass.baseClass) { + left = leftClass.upcast(left); + leftClass = leftClass.baseClass; + } + while (rightClass.baseClass) { + right = rightClass.upcast(right); + rightClass = rightClass.baseClass; + } + return leftClass === rightClass && left === right; + } + function shallowCopyInternalPointer(o) { + return { + count: o.count, + deleteScheduled: o.deleteScheduled, + preservePointerOnDelete: o.preservePointerOnDelete, + ptr: o.ptr, + ptrType: o.ptrType, + smartPtr: o.smartPtr, + smartPtrType: o.smartPtrType, + }; + } + function throwInstanceAlreadyDeleted(obj) { + function getInstanceTypeName(handle) { + return handle.$$.ptrType.registeredClass.name; + } + throwBindingError(getInstanceTypeName(obj) + " instance already deleted"); + } + function ClassHandle_clone() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.preservePointerOnDelete) { + this.$$.count.value += 1; + return this; + } else { + var clone = attachFinalizer( + Object.create(Object.getPrototypeOf(this), { + $$: { value: shallowCopyInternalPointer(this.$$) }, + }), + ); + clone.$$.count.value += 1; + clone.$$.deleteScheduled = false; + return clone; + } + } + function ClassHandle_delete() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion"); + } + detachFinalizer(this); + releaseClassHandle(this.$$); + if (!this.$$.preservePointerOnDelete) { + this.$$.smartPtr = undefined; + this.$$.ptr = undefined; + } + } + function ClassHandle_isDeleted() { + return !this.$$.ptr; + } + function ClassHandle_deleteLater() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion"); + } + deletionQueue.push(this); + if (deletionQueue.length === 1 && delayFunction) { + delayFunction(flushPendingDeletes); + } + this.$$.deleteScheduled = true; + return this; + } + function init_ClassHandle() { + ClassHandle.prototype["isAliasOf"] = ClassHandle_isAliasOf; + ClassHandle.prototype["clone"] = ClassHandle_clone; + ClassHandle.prototype["delete"] = ClassHandle_delete; + ClassHandle.prototype["isDeleted"] = ClassHandle_isDeleted; + ClassHandle.prototype["deleteLater"] = ClassHandle_deleteLater; + } + function ClassHandle() {} + function ensureOverloadTable(proto, methodName, humanName) { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + proto[methodName] = function () { + if (!Object.hasOwn(proto[methodName].overloadTable, arguments.length)) { + throwBindingError( + "Function '" + + humanName + + "' called with an invalid number of arguments (" + + arguments.length + + ") - expects one of (" + + proto[methodName].overloadTable + + ")!", + ); + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments); + }; + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + } + function exposePublicSymbol(name, value, numArguments) { + if (Object.hasOwn(Module, name)) { + if ( + undefined === numArguments || + (undefined !== Module[name].overloadTable && + undefined !== Module[name].overloadTable[numArguments]) + ) { + throwBindingError("Cannot register public name '" + name + "' twice"); + } + ensureOverloadTable(Module, name, name); + if (Object.hasOwn(Module, numArguments)) { + throwBindingError( + "Cannot register multiple overloads of a function with the same number of arguments (" + + numArguments + + ")!", + ); + } + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + } + function RegisteredClass( + name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast, + ) { + this.name = name; + this.constructor = constructor; + this.instancePrototype = instancePrototype; + this.rawDestructor = rawDestructor; + this.baseClass = baseClass; + this.getActualType = getActualType; + this.upcast = upcast; + this.downcast = downcast; + this.pureVirtualFunctions = []; + } + function upcastPointer(ptr, ptrClass, desiredClass) { + while (ptrClass !== desiredClass) { + if (!ptrClass.upcast) { + throwBindingError( + "Expected null or instance of " + + desiredClass.name + + ", got an instance of " + + ptrClass.name, + ); + } + ptr = ptrClass.upcast(ptr); + ptrClass = ptrClass.baseClass; + } + return ptr; + } + function constNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + return 0; + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + function genericPointerToWireType(destructors, handle) { + var ptr; + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + if (this.isSmartPointer) { + ptr = this.rawConstructor(); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + return ptr; + } else { + return 0; + } + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + if (!this.isConst && handle.$$.ptrType.isConst) { + throwBindingError( + "Cannot convert argument of type " + + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + + " to parameter type " + + this.name, + ); + } + var handleClass = handle.$$.ptrType.registeredClass; + ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + if (this.isSmartPointer) { + if (undefined === handle.$$.smartPtr) { + throwBindingError("Passing raw pointer to smart pointer is illegal"); + } + switch (this.sharingPolicy) { + case 0: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + throwBindingError( + "Cannot convert argument of type " + + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + + " to parameter type " + + this.name, + ); + } + break; + case 1: + ptr = handle.$$.smartPtr; + break; + case 2: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle["clone"](); + ptr = this.rawShare( + ptr, + Emval.toHandle(function () { + clonedHandle["delete"](); + }), + ); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + } + break; + default: + throwBindingError("Unsupporting sharing policy"); + } + } + return ptr; + } + function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + return 0; + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + embindRepr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + if (handle.$$.ptrType.isConst) { + throwBindingError( + "Cannot convert argument of type " + + handle.$$.ptrType.name + + " to parameter type " + + this.name, + ); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + function RegisteredPointer_getPointee(ptr) { + if (this.rawGetPointee) { + ptr = this.rawGetPointee(ptr); + } + return ptr; + } + function RegisteredPointer_destructor(ptr) { + if (this.rawDestructor) { + this.rawDestructor(ptr); + } + } + function RegisteredPointer_deleteObject(handle) { + if (handle !== null) { + handle["delete"](); + } + } + function init_RegisteredPointer() { + RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; + RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; + RegisteredPointer.prototype["argPackAdvance"] = 8; + RegisteredPointer.prototype["readValueFromPointer"] = simpleReadValueFromPointer; + RegisteredPointer.prototype["deleteObject"] = RegisteredPointer_deleteObject; + RegisteredPointer.prototype["fromWireType"] = RegisteredPointer_fromWireType; + } + function RegisteredPointer( + name, + registeredClass, + isReference, + isConst, + isSmartPointer, + pointeeType, + sharingPolicy, + rawGetPointee, + rawConstructor, + rawShare, + rawDestructor, + ) { + this.name = name; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + this.isSmartPointer = isSmartPointer; + this.pointeeType = pointeeType; + this.sharingPolicy = sharingPolicy; + this.rawGetPointee = rawGetPointee; + this.rawConstructor = rawConstructor; + this.rawShare = rawShare; + this.rawDestructor = rawDestructor; + if (!isSmartPointer && registeredClass.baseClass === undefined) { + if (isConst) { + this["toWireType"] = constNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } else { + this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } + } else { + this["toWireType"] = genericPointerToWireType; + } + } + function replacePublicSymbol(name, value, numArguments) { + if (!Object.hasOwn(Module, name)) { + throwInternalError("Replacing nonexistant public symbol"); + } + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } else { + Module[name] = value; + Module[name].argCount = numArguments; + } + } + function dynCallLegacy(sig, ptr, args) { + assert( + "dynCall_" + sig in Module, + "bad function pointer type - dynCall function not found for sig '" + sig + "'", + ); + if (args && args.length) { + assert(args.length === sig.substring(1).replace(/j/g, "--").length); + } else { + assert(sig.length == 1); + } + var f = Module["dynCall_" + sig]; + return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr); + } + var wasmTableMirror = []; + function getWasmTableEntry(funcPtr) { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + assert( + wasmTable.get(funcPtr) == func, + "JavaScript-side Wasm function table mirror is out of date!", + ); + return func; + } + function dynCall(sig, ptr, args) { + if (sig.includes("j")) { + return dynCallLegacy(sig, ptr, args); + } + assert(getWasmTableEntry(ptr), "missing table entry in dynCall: " + ptr); + var rtn = getWasmTableEntry(ptr).apply(null, args); + return rtn; + } + function getDynCaller(sig, ptr) { + assert( + sig.includes("j") || sig.includes("p"), + "getDynCaller should only be called with i64 sigs", + ); + var argCache = []; + return function () { + argCache.length = 0; + Object.assign(argCache, arguments); + return dynCall(sig, ptr, argCache); + }; + } + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + function makeDynCaller() { + if (signature.includes("j")) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + var fp = makeDynCaller(); + if (typeof fp != "function") { + throwBindingError( + "unknown function pointer with signature " + signature + ": " + rawFunction, + ); + } + return fp; + } + var UnboundTypeError = undefined; + function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([", "])); + } + function __embind_register_class( + rawType, + rawPointerType, + rawConstPointerType, + baseClassRawType, + getActualTypeSignature, + getActualType, + upcastSignature, + upcast, + downcastSignature, + downcast, + name, + destructorSignature, + rawDestructor, + ) { + name = readLatin1String(name); + getActualType = embind__requireFunction(getActualTypeSignature, getActualType); + if (upcast) { + upcast = embind__requireFunction(upcastSignature, upcast); + } + if (downcast) { + downcast = embind__requireFunction(downcastSignature, downcast); + } + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + var legalFunctionName = makeLegalFunctionName(name); + exposePublicSymbol(legalFunctionName, function () { + throwUnboundTypeError("Cannot construct " + name + " due to unbound types", [ + baseClassRawType, + ]); + }); + whenDependentTypesAreResolved( + [rawType, rawPointerType, rawConstPointerType], + baseClassRawType ? [baseClassRawType] : [], + function (base) { + base = base[0]; + var baseClass; + var basePrototype; + if (baseClassRawType) { + baseClass = base.registeredClass; + basePrototype = baseClass.instancePrototype; + } else { + basePrototype = ClassHandle.prototype; + } + var constructor = createNamedFunction(legalFunctionName, function () { + if (Object.getPrototypeOf(this) !== instancePrototype) { + throw new BindingError("Use 'new' to construct " + name); + } + if (undefined === registeredClass.constructor_body) { + throw new BindingError(name + " has no accessible constructor"); + } + var body = registeredClass.constructor_body[arguments.length]; + if (undefined === body) { + throw new BindingError( + "Tried to invoke ctor of " + + name + + " with invalid number of parameters (" + + arguments.length + + ") - expected (" + + Object.keys(registeredClass.constructor_body).toString() + + ") parameters instead!", + ); + } + return body.apply(this, arguments); + }); + var instancePrototype = Object.create(basePrototype, { + constructor: { value: constructor }, + }); + constructor.prototype = instancePrototype; + var registeredClass = new RegisteredClass( + name, + constructor, + instancePrototype, + rawDestructor, + baseClass, + getActualType, + upcast, + downcast, + ); + var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false); + var pointerConverter = new RegisteredPointer( + name + "*", + registeredClass, + false, + false, + false, + ); + var constPointerConverter = new RegisteredPointer( + name + " const*", + registeredClass, + false, + true, + false, + ); + registeredPointers[rawType] = { + pointerType: pointerConverter, + constPointerType: constPointerConverter, + }; + replacePublicSymbol(legalFunctionName, constructor); + return [referenceConverter, pointerConverter, constPointerConverter]; + }, + ); + } + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) { + var argCount = argTypes.length; + if (argCount < 2) { + throwBindingError( + "argTypes array size mismatch! Must at least get return value and 'this' types!", + ); + } + var isClassMethodFunc = argTypes[1] !== null && classType !== null; + var needsDestructorStack = false; + for (var i = 1; i < argTypes.length; ++i) { + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + needsDestructorStack = true; + break; + } + } + var returns = argTypes[0].name !== "void"; + var expectedArgCount = argCount - 2; + var argsWired = new Array(expectedArgCount); + var invokerFuncArgs = []; + var destructors = []; + return function () { + if (arguments.length !== expectedArgCount) { + throwBindingError( + "function " + + humanName + + " called with " + + arguments.length + + " arguments, expected " + + expectedArgCount + + " args!", + ); + } + destructors.length = 0; + var thisWired; + invokerFuncArgs.length = isClassMethodFunc ? 2 : 1; + invokerFuncArgs[0] = cppTargetFunc; + if (isClassMethodFunc) { + thisWired = argTypes[1]["toWireType"](destructors, this); + invokerFuncArgs[1] = thisWired; + } + for (var i = 0; i < expectedArgCount; ++i) { + argsWired[i] = argTypes[i + 2]["toWireType"](destructors, arguments[i]); + invokerFuncArgs.push(argsWired[i]); + } + var rv = cppInvokerFunc.apply(null, invokerFuncArgs); + function onDone(rv) { + if (needsDestructorStack) { + runDestructors(destructors); + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; i++) { + var param = i === 1 ? thisWired : argsWired[i - 2]; + if (argTypes[i].destructorFunction !== null) { + argTypes[i].destructorFunction(param); + } + } + } + if (returns) { + return argTypes[0]["fromWireType"](rv); + } + } + return onDone(rv); + }; + } + function heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAPU32[(firstElement + i * 4) >> 2]); + } + return array; + } + function __embind_register_class_class_function( + rawClassType, + methodName, + argCount, + rawArgTypesAddr, + invokerSignature, + rawInvoker, + fn, + ) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + methodName; + function unboundTypesHandler() { + throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes); + } + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + var proto = classType.registeredClass.constructor; + if (undefined === proto[methodName]) { + unboundTypesHandler.argCount = argCount - 1; + proto[methodName] = unboundTypesHandler; + } else { + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler; + } + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1)); + var func = craftInvokerFunction(humanName, invokerArgsArray, null, rawInvoker, fn); + if (undefined === proto[methodName].overloadTable) { + func.argCount = argCount - 1; + proto[methodName] = func; + } else { + proto[methodName].overloadTable[argCount - 1] = func; + } + return []; + }); + return []; + }); + } + function __embind_register_class_constructor( + rawClassType, + argCount, + rawArgTypesAddr, + invokerSignature, + invoker, + rawConstructor, + ) { + assert(argCount > 0); + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = "constructor " + classType.name; + if (undefined === classType.registeredClass.constructor_body) { + classType.registeredClass.constructor_body = []; + } + if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) { + throw new BindingError( + "Cannot register multiple constructors with identical number of parameters (" + + (argCount - 1) + + ") for class '" + + classType.name + + "'! Overload resolution is currently only performed using the parameter count, not actual type info!", + ); + } + classType.registeredClass.constructor_body[argCount - 1] = () => { + throwUnboundTypeError( + "Cannot construct " + classType.name + " due to unbound types", + rawArgTypes, + ); + }; + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + argTypes.splice(1, 0, null); + classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction( + humanName, + argTypes, + null, + invoker, + rawConstructor, + ); + return []; + }); + return []; + }); + } + function __embind_register_class_function( + rawClassType, + methodName, + argCount, + rawArgTypesAddr, + invokerSignature, + rawInvoker, + context, + isPureVirtual, + ) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + methodName; + if (methodName.startsWith("@@")) { + methodName = Symbol[methodName.substring(2)]; + } + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName); + } + function unboundTypesHandler() { + throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes); + } + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if ( + undefined === method || + (undefined === method.overloadTable && + method.className !== classType.name && + method.argCount === argCount - 2) + ) { + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler; + } else { + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler; + } + whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) { + var memberFunction = craftInvokerFunction( + humanName, + argTypes, + classType, + rawInvoker, + context, + ); + if (undefined === proto[methodName].overloadTable) { + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction; + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction; + } + return []; + }); + return []; + }); + } + function validateThis(this_, classType, humanName) { + if (!(this_ instanceof Object)) { + throwBindingError(humanName + ' with invalid "this": ' + this_); + } + if (!(this_ instanceof classType.registeredClass.constructor)) { + throwBindingError( + humanName + ' incompatible with "this" of type ' + this_.constructor.name, + ); + } + if (!this_.$$.ptr) { + throwBindingError( + "cannot call emscripten binding method " + humanName + " on deleted object", + ); + } + return upcastPointer( + this_.$$.ptr, + this_.$$.ptrType.registeredClass, + classType.registeredClass, + ); + } + function __embind_register_class_property( + classType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext, + ) { + fieldName = readLatin1String(fieldName); + getter = embind__requireFunction(getterSignature, getter); + whenDependentTypesAreResolved([], [classType], function (classType) { + classType = classType[0]; + var humanName = classType.name + "." + fieldName; + var desc = { + get: function () { + throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [ + getterReturnType, + setterArgumentType, + ]); + }, + enumerable: true, + configurable: true, + }; + if (setter) { + desc.set = () => { + throwUnboundTypeError("Cannot access " + humanName + " due to unbound types", [ + getterReturnType, + setterArgumentType, + ]); + }; + } else { + desc.set = (v) => { + throwBindingError(humanName + " is a read-only property"); + }; + } + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + whenDependentTypesAreResolved( + [], + setter ? [getterReturnType, setterArgumentType] : [getterReturnType], + function (types) { + var getterReturnType = types[0]; + var desc = { + get: function () { + var ptr = validateThis(this, classType, humanName + " getter"); + return getterReturnType["fromWireType"](getter(getterContext, ptr)); + }, + enumerable: true, + }; + if (setter) { + setter = embind__requireFunction(setterSignature, setter); + var setterArgumentType = types[1]; + desc.set = function (v) { + var ptr = validateThis(this, classType, humanName + " setter"); + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, v)); + runDestructors(destructors); + }; + } + Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc); + return []; + }, + ); + return []; + }); + } + function __emval_decref(handle) { + if (handle > 4 && 0 === --emval_handle_array[handle].refcount) { + emval_handle_array[handle] = undefined; + emval_free_list.push(handle); + } + } + function __embind_register_emval(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + name: name, + fromWireType: function (handle) { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + toWireType: function (destructors, value) { + return Emval.toHandle(value); + }, + argPackAdvance: 8, + readValueFromPointer: simpleReadValueFromPointer, + destructorFunction: null, + }); + } + function embindRepr(v) { + if (v === null) { + return "null"; + } + var t = typeof v; + if (t === "object" || t === "array" || t === "function") { + return v.toString(); + } else { + return "" + v; + } + } + function floatReadValueFromPointer(name, shift) { + switch (shift) { + case 2: + return function (pointer) { + return this["fromWireType"](HEAPF32[pointer >> 2]); + }; + case 3: + return function (pointer) { + return this["fromWireType"](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name); + } + } + function __embind_register_float(rawType, name, size) { + var shift = getShiftFromSize(size); + name = readLatin1String(name); + registerType(rawType, { + name: name, + fromWireType: function (value) { + return value; + }, + toWireType: function (destructors, value) { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError('Cannot convert "' + embindRepr(value) + '" to ' + this.name); + } + return value; + }, + argPackAdvance: 8, + readValueFromPointer: floatReadValueFromPointer(name, shift), + destructorFunction: null, + }); + } + function __embind_register_function( + name, + argCount, + rawArgTypesAddr, + signature, + rawInvoker, + fn, + ) { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + rawInvoker = embind__requireFunction(signature, rawInvoker); + exposePublicSymbol( + name, + function () { + throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes); + }, + argCount - 1, + ); + whenDependentTypesAreResolved([], argTypes, function (argTypes) { + var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1)); + replacePublicSymbol( + name, + craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), + argCount - 1, + ); + return []; + }); + } + function integerReadValueFromPointer(name, shift, signed) { + switch (shift) { + case 0: + return signed + ? function readS8FromPointer(pointer) { + return HEAP8[pointer]; + } + : function readU8FromPointer(pointer) { + return HEAPU8[pointer]; + }; + case 1: + return signed + ? function readS16FromPointer(pointer) { + return HEAP16[pointer >> 1]; + } + : function readU16FromPointer(pointer) { + return HEAPU16[pointer >> 1]; + }; + case 2: + return signed + ? function readS32FromPointer(pointer) { + return HEAP32[pointer >> 2]; + } + : function readU32FromPointer(pointer) { + return HEAPU32[pointer >> 2]; + }; + default: + throw new TypeError("Unknown integer type: " + name); + } + } + function __embind_register_integer(primitiveType, name, size, minRange, maxRange) { + name = readLatin1String(name); + if (maxRange === -1) { + maxRange = 4294967295; + } + var shift = getShiftFromSize(size); + var fromWireType = (value) => value; + if (minRange === 0) { + var bitshift = 32 - 8 * size; + fromWireType = (value) => (value << bitshift) >>> bitshift; + } + var isUnsignedType = name.includes("unsigned"); + var checkAssertions = (value, toTypeName) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError('Cannot convert "' + embindRepr(value) + '" to ' + toTypeName); + } + if (value < minRange || value > maxRange) { + throw new TypeError( + 'Passing a number "' + + embindRepr(value) + + '" from JS side to C/C++ side to an argument of type "' + + name + + '", which is outside the valid range [' + + minRange + + ", " + + maxRange + + "]!", + ); + } + }; + var toWireType; + if (isUnsignedType) { + toWireType = function (destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + }; + } else { + toWireType = function (destructors, value) { + checkAssertions(value, this.name); + return value; + }; + } + registerType(primitiveType, { + name: name, + fromWireType: fromWireType, + toWireType: toWireType, + argPackAdvance: 8, + readValueFromPointer: integerReadValueFromPointer(name, shift, minRange !== 0), + destructorFunction: null, + }); + } + function __embind_register_memory_view(rawType, dataTypeIndex, name) { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + var TA = typeMapping[dataTypeIndex]; + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; + var data = heap[handle + 1]; + return new TA(buffer, data, size); + } + name = readLatin1String(name); + registerType( + rawType, + { + name: name, + fromWireType: decodeMemoryView, + argPackAdvance: 8, + readValueFromPointer: decodeMemoryView, + }, + { ignoreDuplicateRegistrations: true }, + ); + } + function __embind_register_std_string(rawType, name) { + name = readLatin1String(name); + var stdStringIsUTF8 = name === "std::string"; + registerType(rawType, { + name: name, + fromWireType: function (value) { + var length = HEAPU32[value >> 2]; + var payload = value + 4; + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = payload; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = payload + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[payload + i]); + } + str = a.join(""); + } + _free(value); + return str; + }, + toWireType: function (destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + var length; + var valueIsOfTypeString = typeof value == "string"; + if ( + !( + valueIsOfTypeString || + value instanceof Uint8Array || + value instanceof Uint8ClampedArray || + value instanceof Int8Array + ) + ) { + throwBindingError("Cannot pass non-string to std::string"); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + var base = _malloc(4 + length + 1); + var ptr = base + 4; + HEAPU32[base >> 2] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError("String has UTF-16 code units that do not fit in 8 bits"); + } + HEAPU8[ptr + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + i] = value[i]; + } + } + } + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + argPackAdvance: 8, + readValueFromPointer: simpleReadValueFromPointer, + destructorFunction: function (ptr) { + _free(ptr); + }, + }); + } + var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined; + function UTF16ToString(ptr, maxBytesToRead) { + assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!"); + var endPtr = ptr; + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + if (endPtr - ptr > 32 && UTF16Decoder) + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + var str = ""; + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(ptr + i * 2) >> 1]; + if (codeUnit == 0) break; + str += String.fromCharCode(codeUnit); + } + return str; + } + function stringToUTF16(str, outPtr, maxBytesToWrite) { + assert(outPtr % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!"); + assert( + typeof maxBytesToWrite == "number", + "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!", + ); + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; + var startPtr = outPtr; + var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + var codeUnit = str.charCodeAt(i); + HEAP16[outPtr >> 1] = codeUnit; + outPtr += 2; + } + HEAP16[outPtr >> 1] = 0; + return outPtr - startPtr; + } + function lengthBytesUTF16(str) { + return str.length * 2; + } + function UTF32ToString(ptr, maxBytesToRead) { + assert(ptr % 4 == 0, "Pointer passed to UTF32ToString must be aligned to four bytes!"); + var i = 0; + var str = ""; + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(ptr + i * 4) >> 2]; + if (utf32 == 0) break; + ++i; + if (utf32 >= 65536) { + var ch = utf32 - 65536; + str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; + } + function stringToUTF32(str, outPtr, maxBytesToWrite) { + assert(outPtr % 4 == 0, "Pointer passed to stringToUTF32 must be aligned to four bytes!"); + assert( + typeof maxBytesToWrite == "number", + "stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!", + ); + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = (65536 + ((codeUnit & 1023) << 10)) | (trailSurrogate & 1023); + } + HEAP32[outPtr >> 2] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + HEAP32[outPtr >> 2] = 0; + return outPtr - startPtr; + } + function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) ++i; + len += 4; + } + return len; + } + function __embind_register_std_wstring(rawType, charSize, name) { + name = readLatin1String(name); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = () => HEAPU16; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = () => HEAPU32; + shift = 2; + } + registerType(rawType, { + name: name, + fromWireType: function (value) { + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || HEAP[currentBytePtr >> shift] == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + _free(value); + return str; + }, + toWireType: function (destructors, value) { + if (!(typeof value == "string")) { + throwBindingError("Cannot pass non-string to C++ string type " + name); + } + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + encodeString(value, ptr + 4, length + charSize); + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + argPackAdvance: 8, + readValueFromPointer: simpleReadValueFromPointer, + destructorFunction: function (ptr) { + _free(ptr); + }, + }); + } + function __embind_register_value_object( + rawType, + name, + constructorSignature, + rawConstructor, + destructorSignature, + rawDestructor, + ) { + structRegistrations[rawType] = { + name: readLatin1String(name), + rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), + rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), + fields: [], + }; + } + function __embind_register_value_object_field( + structType, + fieldName, + getterReturnType, + getterSignature, + getter, + getterContext, + setterArgumentType, + setterSignature, + setter, + setterContext, + ) { + structRegistrations[structType].fields.push({ + fieldName: readLatin1String(fieldName), + getterReturnType: getterReturnType, + getter: embind__requireFunction(getterSignature, getter), + getterContext: getterContext, + setterArgumentType: setterArgumentType, + setter: embind__requireFunction(setterSignature, setter), + setterContext: setterContext, + }); + } + function __embind_register_void(rawType, name) { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, + name: name, + argPackAdvance: 0, + fromWireType: function () { + return undefined; + }, + toWireType: function (destructors, o) { + return undefined; + }, + }); + } + var nowIsMonotonic = true; + function __emscripten_get_now_is_monotonic() { + return nowIsMonotonic; + } + function __emval_as(handle, returnType, destructorsRef) { + handle = Emval.toValue(handle); + returnType = requireRegisteredType(returnType, "emval::as"); + var destructors = []; + var rd = Emval.toHandle(destructors); + HEAPU32[destructorsRef >> 2] = rd; + return returnType["toWireType"](destructors, handle); + } + var emval_symbols = {}; + function getStringOrSymbol(address) { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return readLatin1String(address); + } + return symbol; + } + var emval_methodCallers = []; + function __emval_call_void_method(caller, handle, methodName, args) { + caller = emval_methodCallers[caller]; + handle = Emval.toValue(handle); + methodName = getStringOrSymbol(methodName); + caller(handle, methodName, null, args); + } + function emval_get_global() { + if (typeof globalThis == "object") { + return globalThis; + } + function testGlobal(obj) { + obj["$$$embind_global$$$"] = obj; + var success = typeof $$$embind_global$$$ == "object" && obj["$$$embind_global$$$"] == obj; + if (!success) { + delete obj["$$$embind_global$$$"]; + } + return success; + } + if (typeof $$$embind_global$$$ == "object") { + return $$$embind_global$$$; + } + if (typeof global == "object" && testGlobal(global)) { + $$$embind_global$$$ = global; + } else if (typeof self == "object" && testGlobal(self)) { + $$$embind_global$$$ = self; + } + if (typeof $$$embind_global$$$ == "object") { + return $$$embind_global$$$; + } + throw Error("unable to get global object."); + } + function __emval_get_global(name) { + if (name === 0) { + return Emval.toHandle(emval_get_global()); + } else { + name = getStringOrSymbol(name); + return Emval.toHandle(emval_get_global()[name]); + } + } + function emval_addMethodCaller(caller) { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; + } + function emval_lookupTypes(argCount, argTypes) { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(HEAPU32[(argTypes + i * POINTER_SIZE) >> 2], "parameter " + i); + } + return a; + } + var emval_registeredMethods = []; + function __emval_get_method_caller(argCount, argTypes) { + var types = emval_lookupTypes(argCount, argTypes); + var retType = types[0]; + var signatureName = + retType.name + + "_$" + + types + .slice(1) + .map(function (t) { + return t.name; + }) + .join("_") + + "$"; + var returnId = emval_registeredMethods[signatureName]; + if (returnId !== undefined) { + return returnId; + } + var argN = new Array(argCount - 1); + var invokerFunction = (handle, name, destructors, args) => { + var offset = 0; + for (var i = 0; i < argCount - 1; ++i) { + argN[i] = types[i + 1]["readValueFromPointer"](args + offset); + offset += types[i + 1]["argPackAdvance"]; + } + var rv = handle[name].apply(handle, argN); + for (var i = 0; i < argCount - 1; ++i) { + if (types[i + 1].deleteObject) { + types[i + 1].deleteObject(argN[i]); + } + } + if (!retType.isVoid) { + return retType["toWireType"](destructors, rv); + } + }; + returnId = emval_addMethodCaller(invokerFunction); + emval_registeredMethods[signatureName] = returnId; + return returnId; + } + function __emval_get_property(handle, key) { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + return Emval.toHandle(handle[key]); + } + function __emval_incref(handle) { + if (handle > 4) { + emval_handle_array[handle].refcount += 1; + } + } + function __emval_instanceof(object, constructor) { + object = Emval.toValue(object); + constructor = Emval.toValue(constructor); + return object instanceof constructor; + } + function __emval_new_cstring(v) { + return Emval.toHandle(getStringOrSymbol(v)); + } + function __emval_run_destructors(handle) { + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); + } + function __emval_set_property(handle, key, value) { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + value = Emval.toValue(value); + handle[key] = value; + } + function __emval_take_value(type, arg) { + type = requireRegisteredType(type, "_emval_take_value"); + var v = type["readValueFromPointer"](arg); + return Emval.toHandle(v); + } + function __emval_typeof(handle) { + handle = Emval.toValue(handle); + return Emval.toHandle(typeof handle); + } + function readI53FromI64(ptr) { + return HEAPU32[ptr >> 2] + HEAP32[(ptr + 4) >> 2] * 4294967296; + } + function __gmtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time) * 1e3); + HEAP32[tmPtr >> 2] = date.getUTCSeconds(); + HEAP32[(tmPtr + 4) >> 2] = date.getUTCMinutes(); + HEAP32[(tmPtr + 8) >> 2] = date.getUTCHours(); + HEAP32[(tmPtr + 12) >> 2] = date.getUTCDate(); + HEAP32[(tmPtr + 16) >> 2] = date.getUTCMonth(); + HEAP32[(tmPtr + 20) >> 2] = date.getUTCFullYear() - 1900; + HEAP32[(tmPtr + 24) >> 2] = date.getUTCDay(); + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = ((date.getTime() - start) / (1e3 * 60 * 60 * 24)) | 0; + HEAP32[(tmPtr + 28) >> 2] = yday; + } + function __isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + } + var __MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]; + var __MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; + function __yday_from_date(date) { + var isLeapYear = __isLeapYear(date.getFullYear()); + var monthDaysCumulative = isLeapYear + ? __MONTH_DAYS_LEAP_CUMULATIVE + : __MONTH_DAYS_REGULAR_CUMULATIVE; + var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; + return yday; + } + function __localtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time) * 1e3); + HEAP32[tmPtr >> 2] = date.getSeconds(); + HEAP32[(tmPtr + 4) >> 2] = date.getMinutes(); + HEAP32[(tmPtr + 8) >> 2] = date.getHours(); + HEAP32[(tmPtr + 12) >> 2] = date.getDate(); + HEAP32[(tmPtr + 16) >> 2] = date.getMonth(); + HEAP32[(tmPtr + 20) >> 2] = date.getFullYear() - 1900; + HEAP32[(tmPtr + 24) >> 2] = date.getDay(); + var yday = __yday_from_date(date) | 0; + HEAP32[(tmPtr + 28) >> 2] = yday; + HEAP32[(tmPtr + 36) >> 2] = -(date.getTimezoneOffset() * 60); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = + (summerOffset != winterOffset && + date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0; + HEAP32[(tmPtr + 32) >> 2] = dst; + } + function __mktime_js(tmPtr) { + var date = new Date( + HEAP32[(tmPtr + 20) >> 2] + 1900, + HEAP32[(tmPtr + 16) >> 2], + HEAP32[(tmPtr + 12) >> 2], + HEAP32[(tmPtr + 8) >> 2], + HEAP32[(tmPtr + 4) >> 2], + HEAP32[tmPtr >> 2], + 0, + ); + var dst = HEAP32[(tmPtr + 32) >> 2]; + var guessedOffset = date.getTimezoneOffset(); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dstOffset = Math.min(winterOffset, summerOffset); + if (dst < 0) { + HEAP32[(tmPtr + 32) >> 2] = Number( + summerOffset != winterOffset && dstOffset == guessedOffset, + ); + } else if (dst > 0 != (dstOffset == guessedOffset)) { + var nonDstOffset = Math.max(winterOffset, summerOffset); + var trueOffset = dst > 0 ? dstOffset : nonDstOffset; + date.setTime(date.getTime() + (trueOffset - guessedOffset) * 6e4); + } + HEAP32[(tmPtr + 24) >> 2] = date.getDay(); + var yday = __yday_from_date(date) | 0; + HEAP32[(tmPtr + 28) >> 2] = yday; + HEAP32[tmPtr >> 2] = date.getSeconds(); + HEAP32[(tmPtr + 4) >> 2] = date.getMinutes(); + HEAP32[(tmPtr + 8) >> 2] = date.getHours(); + HEAP32[(tmPtr + 12) >> 2] = date.getDate(); + HEAP32[(tmPtr + 16) >> 2] = date.getMonth(); + HEAP32[(tmPtr + 20) >> 2] = date.getYear(); + return (date.getTime() / 1e3) | 0; + } + function __mmap_js(len, prot, flags, fd, off, allocated, addr) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var res = FS.mmap(stream, len, off, prot, flags); + var ptr = res.ptr; + HEAP32[allocated >> 2] = res.allocated; + HEAPU32[addr >> 2] = ptr; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function __munmap_js(addr, len, prot, flags, fd, offset) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + if (prot & 2) { + SYSCALLS.doMsync(addr, stream, len, flags, offset); + } + FS.munmap(stream); + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return -e.errno; + } + } + function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; + } + function __tzset_js(timezone, daylight, tzname) { + var currentYear = new Date().getFullYear(); + var winter = new Date(currentYear, 0, 1); + var summer = new Date(currentYear, 6, 1); + var winterOffset = winter.getTimezoneOffset(); + var summerOffset = summer.getTimezoneOffset(); + var stdTimezoneOffset = Math.max(winterOffset, summerOffset); + HEAPU32[timezone >> 2] = stdTimezoneOffset * 60; + HEAP32[daylight >> 2] = Number(winterOffset != summerOffset); + function extractZone(date) { + var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/); + return match ? match[1] : "GMT"; + } + var winterName = extractZone(winter); + var summerName = extractZone(summer); + var winterNamePtr = allocateUTF8(winterName); + var summerNamePtr = allocateUTF8(summerName); + if (summerOffset < winterOffset) { + HEAPU32[tzname >> 2] = winterNamePtr; + HEAPU32[(tzname + 4) >> 2] = summerNamePtr; + } else { + HEAPU32[tzname >> 2] = summerNamePtr; + HEAPU32[(tzname + 4) >> 2] = winterNamePtr; + } + } + function _abort() { + abort("native code called abort()"); + } + var readEmAsmArgsArray = []; + function readEmAsmArgs(sigPtr, buf) { + assert(Array.isArray(readEmAsmArgsArray)); + assert(buf % 16 == 0); + readEmAsmArgsArray.length = 0; + var ch; + buf >>= 2; + while ((ch = HEAPU8[sigPtr++])) { + var chr = String.fromCharCode(ch); + var validChars = ["d", "f", "i"]; + assert( + validChars.includes(chr), + "Invalid character " + + ch + + '("' + + chr + + '") in readEmAsmArgs! Use only [' + + validChars + + '], and do not specify "v" for void return argument.', + ); + buf += (ch != 105) & buf; + readEmAsmArgsArray.push(ch == 105 ? HEAP32[buf] : HEAPF64[buf++ >> 1]); + ++buf; + } + return readEmAsmArgsArray; + } + function runEmAsmFunction(code, sigPtr, argbuf) { + var args = readEmAsmArgs(sigPtr, argbuf); + if (!Object.hasOwn(ASM_CONSTS, code)) abort("No EM_ASM constant found at address " + code); + return ASM_CONSTS[code].apply(null, args); + } + function _emscripten_asm_const_int(code, sigPtr, argbuf) { + return runEmAsmFunction(code, sigPtr, argbuf); + } + function _emscripten_date_now() { + return Date.now(); + } + function getHeapMax() { + return 2147483648; + } + function _emscripten_get_heap_max() { + return getHeapMax(); + } + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + function _emscripten_pc_get_function(pc) { + abort("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER"); + } + function emscripten_realloc_buffer(size) { + try { + wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16); + updateGlobalBufferAndViews(wasmMemory.buffer); + return 1; + } catch (e) { + err( + "emscripten_realloc_buffer: Attempted to grow heap from " + + buffer.byteLength + + " bytes to " + + size + + " bytes, but got error: " + + e, + ); + } + } + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + assert(requestedSize > oldSize); + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + err( + "Cannot enlarge memory, asked to go up to " + + requestedSize + + " bytes, but the limit is " + + maxHeapSize + + " bytes!", + ); + return false; + } + let alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple); + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min( + maxHeapSize, + alignUp(Math.max(requestedSize, overGrownHeapSize), 65536), + ); + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + return true; + } + } + err( + "Failed to grow the heap from " + + oldSize + + " bytes to " + + newSize + + " bytes, not enough memory!", + ); + return false; + } + function convertFrameToPC(frame) { + abort( + "Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER", + ); + return 0; + } + var UNWIND_CACHE = {}; + function saveInUnwindCache(callstack) { + callstack.forEach((frame) => { + var pc = convertFrameToPC(frame); + if (pc) { + UNWIND_CACHE[pc] = frame; + } + }); + } + function jsStackTrace() { + var error = new Error(); + if (!error.stack) { + try { + throw new Error(); + } catch (e) { + error = e; + } + if (!error.stack) { + return "(no stack trace available)"; + } + } + return error.stack.toString(); + } + function _emscripten_stack_snapshot() { + var callstack = jsStackTrace().split("\n"); + if (callstack[0] == "Error") { + callstack.shift(); + } + saveInUnwindCache(callstack); + UNWIND_CACHE.last_addr = convertFrameToPC(callstack[3]); + UNWIND_CACHE.last_stack = callstack; + return UNWIND_CACHE.last_addr; + } + function _emscripten_stack_unwind_buffer(addr, buffer, count) { + var stack; + if (UNWIND_CACHE.last_addr == addr) { + stack = UNWIND_CACHE.last_stack; + } else { + stack = jsStackTrace().split("\n"); + if (stack[0] == "Error") { + stack.shift(); + } + saveInUnwindCache(stack); + } + var offset = 3; + while (stack[offset] && convertFrameToPC(stack[offset]) != addr) { + ++offset; + } + for (var i = 0; i < count && stack[i + offset]; ++i) { + HEAP32[(buffer + i * 4) >> 2] = convertFrameToPC(stack[i + offset]); + } + return i; + } + function __webgl_enable_ANGLE_instanced_arrays(ctx) { + var ext = ctx.getExtension("ANGLE_instanced_arrays"); + if (ext) { + ctx["vertexAttribDivisor"] = function (index, divisor) { + ext["vertexAttribDivisorANGLE"](index, divisor); + }; + ctx["drawArraysInstanced"] = function (mode, first, count, primcount) { + ext["drawArraysInstancedANGLE"](mode, first, count, primcount); + }; + ctx["drawElementsInstanced"] = function (mode, count, type, indices, primcount) { + ext["drawElementsInstancedANGLE"](mode, count, type, indices, primcount); + }; + return 1; + } + } + function __webgl_enable_OES_vertex_array_object(ctx) { + var ext = ctx.getExtension("OES_vertex_array_object"); + if (ext) { + ctx["createVertexArray"] = function () { + return ext["createVertexArrayOES"](); + }; + ctx["deleteVertexArray"] = function (vao) { + ext["deleteVertexArrayOES"](vao); + }; + ctx["bindVertexArray"] = function (vao) { + ext["bindVertexArrayOES"](vao); + }; + ctx["isVertexArray"] = function (vao) { + return ext["isVertexArrayOES"](vao); + }; + return 1; + } + } + function __webgl_enable_WEBGL_draw_buffers(ctx) { + var ext = ctx.getExtension("WEBGL_draw_buffers"); + if (ext) { + ctx["drawBuffers"] = function (n, bufs) { + ext["drawBuffersWEBGL"](n, bufs); + }; + return 1; + } + } + function __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(ctx) { + return !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance")); + } + function __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(ctx) { + return !!(ctx.mdibvbi = ctx.getExtension( + "WEBGL_multi_draw_instanced_base_vertex_base_instance", + )); + } + function __webgl_enable_WEBGL_multi_draw(ctx) { + return !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw")); + } + var GL = { + counter: 1, + buffers: [], + mappedBuffers: {}, + programs: [], + framebuffers: [], + renderbuffers: [], + textures: [], + shaders: [], + vaos: [], + contexts: [], + offscreenCanvases: {}, + queries: [], + samplers: [], + transformFeedbacks: [], + syncs: [], + byteSizeByTypeRoot: 5120, + byteSizeByType: [1, 1, 2, 2, 4, 4, 4, 2, 3, 4, 8], + stringCache: {}, + stringiCache: {}, + unpackAlignment: 4, + recordError: function recordError(errorCode) { + if (!GL.lastError) { + GL.lastError = errorCode; + } + }, + getNewId: function (table) { + var ret = GL.counter++; + for (var i = table.length; i < ret; i++) { + table[i] = null; + } + return ret; + }, + MAX_TEMP_BUFFER_SIZE: 2097152, + numTempVertexBuffersPerSize: 64, + log2ceilLookup: function (i) { + return 32 - Math.clz32(i === 0 ? 0 : i - 1); + }, + generateTempBuffers: function (quads, context) { + var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE); + context.tempVertexBufferCounters1 = []; + context.tempVertexBufferCounters2 = []; + context.tempVertexBufferCounters1.length = context.tempVertexBufferCounters2.length = + largestIndex + 1; + context.tempVertexBuffers1 = []; + context.tempVertexBuffers2 = []; + context.tempVertexBuffers1.length = context.tempVertexBuffers2.length = largestIndex + 1; + context.tempIndexBuffers = []; + context.tempIndexBuffers.length = largestIndex + 1; + for (var i = 0; i <= largestIndex; ++i) { + context.tempIndexBuffers[i] = null; + context.tempVertexBufferCounters1[i] = context.tempVertexBufferCounters2[i] = 0; + var ringbufferLength = GL.numTempVertexBuffersPerSize; + context.tempVertexBuffers1[i] = []; + context.tempVertexBuffers2[i] = []; + var ringbuffer1 = context.tempVertexBuffers1[i]; + var ringbuffer2 = context.tempVertexBuffers2[i]; + ringbuffer1.length = ringbuffer2.length = ringbufferLength; + for (var j = 0; j < ringbufferLength; ++j) { + ringbuffer1[j] = ringbuffer2[j] = null; + } + } + if (quads) { + context.tempQuadIndexBuffer = GLctx.createBuffer(); + context.GLctx.bindBuffer(34963, context.tempQuadIndexBuffer); + var numIndexes = GL.MAX_TEMP_BUFFER_SIZE >> 1; + var quadIndexes = new Uint16Array(numIndexes); + var i = 0, + v = 0; + while (1) { + quadIndexes[i++] = v; + if (i >= numIndexes) break; + quadIndexes[i++] = v + 1; + if (i >= numIndexes) break; + quadIndexes[i++] = v + 2; + if (i >= numIndexes) break; + quadIndexes[i++] = v; + if (i >= numIndexes) break; + quadIndexes[i++] = v + 2; + if (i >= numIndexes) break; + quadIndexes[i++] = v + 3; + if (i >= numIndexes) break; + v += 4; + } + context.GLctx.bufferData(34963, quadIndexes, 35044); + context.GLctx.bindBuffer(34963, null); + } + }, + getTempVertexBuffer: function getTempVertexBuffer(sizeBytes) { + var idx = GL.log2ceilLookup(sizeBytes); + var ringbuffer = GL.currentContext.tempVertexBuffers1[idx]; + var nextFreeBufferIndex = GL.currentContext.tempVertexBufferCounters1[idx]; + GL.currentContext.tempVertexBufferCounters1[idx] = + (GL.currentContext.tempVertexBufferCounters1[idx] + 1) & + (GL.numTempVertexBuffersPerSize - 1); + var vbo = ringbuffer[nextFreeBufferIndex]; + if (vbo) { + return vbo; + } + var prevVBO = GLctx.getParameter(34964); + ringbuffer[nextFreeBufferIndex] = GLctx.createBuffer(); + GLctx.bindBuffer(34962, ringbuffer[nextFreeBufferIndex]); + GLctx.bufferData(34962, 1 << idx, 35048); + GLctx.bindBuffer(34962, prevVBO); + return ringbuffer[nextFreeBufferIndex]; + }, + getTempIndexBuffer: function getTempIndexBuffer(sizeBytes) { + var idx = GL.log2ceilLookup(sizeBytes); + var ibo = GL.currentContext.tempIndexBuffers[idx]; + if (ibo) { + return ibo; + } + var prevIBO = GLctx.getParameter(34965); + GL.currentContext.tempIndexBuffers[idx] = GLctx.createBuffer(); + GLctx.bindBuffer(34963, GL.currentContext.tempIndexBuffers[idx]); + GLctx.bufferData(34963, 1 << idx, 35048); + GLctx.bindBuffer(34963, prevIBO); + return GL.currentContext.tempIndexBuffers[idx]; + }, + newRenderingFrameStarted: function newRenderingFrameStarted() { + if (!GL.currentContext) { + return; + } + var vb = GL.currentContext.tempVertexBuffers1; + GL.currentContext.tempVertexBuffers1 = GL.currentContext.tempVertexBuffers2; + GL.currentContext.tempVertexBuffers2 = vb; + vb = GL.currentContext.tempVertexBufferCounters1; + GL.currentContext.tempVertexBufferCounters1 = GL.currentContext.tempVertexBufferCounters2; + GL.currentContext.tempVertexBufferCounters2 = vb; + var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE); + for (var i = 0; i <= largestIndex; ++i) { + GL.currentContext.tempVertexBufferCounters1[i] = 0; + } + }, + getSource: function (shader, count, string, length) { + var source = ""; + for (var i = 0; i < count; ++i) { + var len = length ? HEAP32[(length + i * 4) >> 2] : -1; + source += UTF8ToString(HEAP32[(string + i * 4) >> 2], len < 0 ? undefined : len); + } + return source; + }, + calcBufLength: function calcBufLength(size, type, stride, count) { + if (stride > 0) { + return count * stride; + } + var typeSize = GL.byteSizeByType[type - GL.byteSizeByTypeRoot]; + return size * typeSize * count; + }, + usedTempBuffers: [], + preDrawHandleClientVertexAttribBindings: function preDrawHandleClientVertexAttribBindings( + count, + ) { + GL.resetBufferBinding = false; + for (var i = 0; i < GL.currentContext.maxVertexAttribs; ++i) { + var cb = GL.currentContext.clientBuffers[i]; + if (!cb.clientside || !cb.enabled) continue; + GL.resetBufferBinding = true; + var size = GL.calcBufLength(cb.size, cb.type, cb.stride, count); + var buf = GL.getTempVertexBuffer(size); + GLctx.bindBuffer(34962, buf); + GLctx.bufferSubData(34962, 0, HEAPU8.subarray(cb.ptr, cb.ptr + size)); + cb.vertexAttribPointerAdaptor.call( + GLctx, + i, + cb.size, + cb.type, + cb.normalized, + cb.stride, + 0, + ); + } + }, + postDrawHandleClientVertexAttribBindings: + function postDrawHandleClientVertexAttribBindings() { + if (GL.resetBufferBinding) { + GLctx.bindBuffer(34962, GL.buffers[GLctx.currentArrayBufferBinding]); + } + }, + createContext: function (canvas, webGLContextAttributes) { + if (webGLContextAttributes.renderViaOffscreenBackBuffer) + webGLContextAttributes["preserveDrawingBuffer"] = true; + if (!canvas.getContextSafariWebGL2Fixed) { + canvas.getContextSafariWebGL2Fixed = canvas.getContext; + function fixedGetContext(ver, attrs) { + var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs); + return (ver == "webgl") == gl instanceof WebGLRenderingContext ? gl : null; + } + canvas.getContext = fixedGetContext; + } + var ctx = + webGLContextAttributes.majorVersion > 1 + ? canvas.getContext("webgl2", webGLContextAttributes) + : canvas.getContext("webgl", webGLContextAttributes); + if (!ctx) return 0; + var handle = GL.registerContext(ctx, webGLContextAttributes); + return handle; + }, + enableOffscreenFramebufferAttributes: function (webGLContextAttributes) { + webGLContextAttributes.renderViaOffscreenBackBuffer = true; + webGLContextAttributes.preserveDrawingBuffer = true; + }, + createOffscreenFramebuffer: function (context) { + var gl = context.GLctx; + var fbo = gl.createFramebuffer(); + gl.bindFramebuffer(36160, fbo); + context.defaultFbo = fbo; + context.defaultFboForbidBlitFramebuffer = false; + if (gl.getContextAttributes().antialias) { + context.defaultFboForbidBlitFramebuffer = true; + } else { + var firefoxMatch = navigator.userAgent.toLowerCase().match(/firefox\/(\d\d)/); + if (firefoxMatch != null) { + var firefoxVersion = firefoxMatch[1]; + context.defaultFboForbidBlitFramebuffer = firefoxVersion < 67; + } + } + context.defaultColorTarget = gl.createTexture(); + context.defaultDepthTarget = gl.createRenderbuffer(); + GL.resizeOffscreenFramebuffer(context); + gl.bindTexture(3553, context.defaultColorTarget); + gl.texParameteri(3553, 10241, 9728); + gl.texParameteri(3553, 10240, 9728); + gl.texParameteri(3553, 10242, 33071); + gl.texParameteri(3553, 10243, 33071); + gl.texImage2D(3553, 0, 6408, gl.canvas.width, gl.canvas.height, 0, 6408, 5121, null); + gl.framebufferTexture2D(36160, 36064, 3553, context.defaultColorTarget, 0); + gl.bindTexture(3553, null); + var depthTarget = gl.createRenderbuffer(); + gl.bindRenderbuffer(36161, context.defaultDepthTarget); + gl.renderbufferStorage(36161, 33189, gl.canvas.width, gl.canvas.height); + gl.framebufferRenderbuffer(36160, 36096, 36161, context.defaultDepthTarget); + gl.bindRenderbuffer(36161, null); + var vertices = [-1, -1, -1, 1, 1, -1, 1, 1]; + var vb = gl.createBuffer(); + gl.bindBuffer(34962, vb); + gl.bufferData(34962, new Float32Array(vertices), 35044); + gl.bindBuffer(34962, null); + context.blitVB = vb; + var vsCode = + "attribute vec2 pos;" + + "varying lowp vec2 tex;" + + "void main() { tex = pos * 0.5 + vec2(0.5,0.5); gl_Position = vec4(pos, 0.0, 1.0); }"; + var vs = gl.createShader(35633); + gl.shaderSource(vs, vsCode); + gl.compileShader(vs); + var fsCode = + "varying lowp vec2 tex;" + + "uniform sampler2D sampler;" + + "void main() { gl_FragColor = texture2D(sampler, tex); }"; + var fs = gl.createShader(35632); + gl.shaderSource(fs, fsCode); + gl.compileShader(fs); + var blitProgram = gl.createProgram(); + gl.attachShader(blitProgram, vs); + gl.attachShader(blitProgram, fs); + gl.linkProgram(blitProgram); + context.blitProgram = blitProgram; + context.blitPosLoc = gl.getAttribLocation(blitProgram, "pos"); + gl.useProgram(blitProgram); + gl.uniform1i(gl.getUniformLocation(blitProgram, "sampler"), 0); + gl.useProgram(null); + context.defaultVao = undefined; + if (gl.createVertexArray) { + context.defaultVao = gl.createVertexArray(); + gl.bindVertexArray(context.defaultVao); + gl.enableVertexAttribArray(context.blitPosLoc); + gl.bindVertexArray(null); + } + }, + resizeOffscreenFramebuffer: function (context) { + var gl = context.GLctx; + if (context.defaultColorTarget) { + var prevTextureBinding = gl.getParameter(32873); + gl.bindTexture(3553, context.defaultColorTarget); + gl.texImage2D( + 3553, + 0, + 6408, + gl.drawingBufferWidth, + gl.drawingBufferHeight, + 0, + 6408, + 5121, + null, + ); + gl.bindTexture(3553, prevTextureBinding); + } + if (context.defaultDepthTarget) { + var prevRenderBufferBinding = gl.getParameter(36007); + gl.bindRenderbuffer(36161, context.defaultDepthTarget); + gl.renderbufferStorage(36161, 33189, gl.drawingBufferWidth, gl.drawingBufferHeight); + gl.bindRenderbuffer(36161, prevRenderBufferBinding); + } + }, + blitOffscreenFramebuffer: function (context) { + var gl = context.GLctx; + var prevScissorTest = gl.getParameter(3089); + if (prevScissorTest) gl.disable(3089); + var prevFbo = gl.getParameter(36006); + if (gl.blitFramebuffer && !context.defaultFboForbidBlitFramebuffer) { + gl.bindFramebuffer(36008, context.defaultFbo); + gl.bindFramebuffer(36009, null); + gl.blitFramebuffer( + 0, + 0, + gl.canvas.width, + gl.canvas.height, + 0, + 0, + gl.canvas.width, + gl.canvas.height, + 16384, + 9728, + ); + } else { + gl.bindFramebuffer(36160, null); + var prevProgram = gl.getParameter(35725); + gl.useProgram(context.blitProgram); + var prevVB = gl.getParameter(34964); + gl.bindBuffer(34962, context.blitVB); + var prevActiveTexture = gl.getParameter(34016); + gl.activeTexture(33984); + var prevTextureBinding = gl.getParameter(32873); + gl.bindTexture(3553, context.defaultColorTarget); + var prevBlend = gl.getParameter(3042); + if (prevBlend) gl.disable(3042); + var prevCullFace = gl.getParameter(2884); + if (prevCullFace) gl.disable(2884); + var prevDepthTest = gl.getParameter(2929); + if (prevDepthTest) gl.disable(2929); + var prevStencilTest = gl.getParameter(2960); + if (prevStencilTest) gl.disable(2960); + function draw() { + gl.vertexAttribPointer(context.blitPosLoc, 2, 5126, false, 0, 0); + gl.drawArrays(5, 0, 4); + } + if (context.defaultVao) { + var prevVAO = gl.getParameter(34229); + gl.bindVertexArray(context.defaultVao); + draw(); + gl.bindVertexArray(prevVAO); + } else { + var prevVertexAttribPointer = { + buffer: gl.getVertexAttrib(context.blitPosLoc, 34975), + size: gl.getVertexAttrib(context.blitPosLoc, 34339), + stride: gl.getVertexAttrib(context.blitPosLoc, 34340), + type: gl.getVertexAttrib(context.blitPosLoc, 34341), + normalized: gl.getVertexAttrib(context.blitPosLoc, 34922), + pointer: gl.getVertexAttribOffset(context.blitPosLoc, 34373), + }; + var maxVertexAttribs = gl.getParameter(34921); + var prevVertexAttribEnables = []; + for (var i = 0; i < maxVertexAttribs; ++i) { + var prevEnabled = gl.getVertexAttrib(i, 34338); + var wantEnabled = i == context.blitPosLoc; + if (prevEnabled && !wantEnabled) { + gl.disableVertexAttribArray(i); + } + if (!prevEnabled && wantEnabled) { + gl.enableVertexAttribArray(i); + } + prevVertexAttribEnables[i] = prevEnabled; + } + draw(); + for (var i = 0; i < maxVertexAttribs; ++i) { + var prevEnabled = prevVertexAttribEnables[i]; + var nowEnabled = i == context.blitPosLoc; + if (prevEnabled && !nowEnabled) { + gl.enableVertexAttribArray(i); + } + if (!prevEnabled && nowEnabled) { + gl.disableVertexAttribArray(i); + } + } + gl.bindBuffer(34962, prevVertexAttribPointer.buffer); + gl.vertexAttribPointer( + context.blitPosLoc, + prevVertexAttribPointer.size, + prevVertexAttribPointer.type, + prevVertexAttribPointer.normalized, + prevVertexAttribPointer.stride, + prevVertexAttribPointer.offset, + ); + } + if (prevStencilTest) gl.enable(2960); + if (prevDepthTest) gl.enable(2929); + if (prevCullFace) gl.enable(2884); + if (prevBlend) gl.enable(3042); + gl.bindTexture(3553, prevTextureBinding); + gl.activeTexture(prevActiveTexture); + gl.bindBuffer(34962, prevVB); + gl.useProgram(prevProgram); + } + gl.bindFramebuffer(36160, prevFbo); + if (prevScissorTest) gl.enable(3089); + }, + registerContext: function (ctx, webGLContextAttributes) { + var handle = GL.getNewId(GL.contexts); + var context = { + handle: handle, + attributes: webGLContextAttributes, + version: webGLContextAttributes.majorVersion, + GLctx: ctx, + }; + if (ctx.canvas) ctx.canvas.GLctxObject = context; + GL.contexts[handle] = context; + if ( + typeof webGLContextAttributes.enableExtensionsByDefault == "undefined" || + webGLContextAttributes.enableExtensionsByDefault + ) { + GL.initExtensions(context); + } + context.maxVertexAttribs = context.GLctx.getParameter(34921); + context.clientBuffers = []; + for (var i = 0; i < context.maxVertexAttribs; i++) { + context.clientBuffers[i] = { + enabled: false, + clientside: false, + size: 0, + type: 0, + normalized: 0, + stride: 0, + ptr: 0, + vertexAttribPointerAdaptor: null, + }; + } + GL.generateTempBuffers(false, context); + if (webGLContextAttributes.renderViaOffscreenBackBuffer) + GL.createOffscreenFramebuffer(context); + return handle; + }, + makeContextCurrent: function (contextHandle) { + GL.currentContext = GL.contexts[contextHandle]; + Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx; + return !(contextHandle && !GLctx); + }, + getContext: function (contextHandle) { + return GL.contexts[contextHandle]; + }, + deleteContext: function (contextHandle) { + if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null; + if (typeof JSEvents == "object") + JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas); + if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) + GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined; + GL.contexts[contextHandle] = null; + }, + initExtensions: function (context) { + if (!context) context = GL.currentContext; + if (context.initExtensionsDone) return; + context.initExtensionsDone = true; + var GLctx = context.GLctx; + __webgl_enable_ANGLE_instanced_arrays(GLctx); + __webgl_enable_OES_vertex_array_object(GLctx); + __webgl_enable_WEBGL_draw_buffers(GLctx); + __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx); + __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx); + if (context.version >= 2) { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2"); + } + if (context.version < 2 || !GLctx.disjointTimerQueryExt) { + GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query"); + } + __webgl_enable_WEBGL_multi_draw(GLctx); + var exts = GLctx.getSupportedExtensions() || []; + exts.forEach(function (ext) { + if (!ext.includes("lose_context") && !ext.includes("debug")) { + GLctx.getExtension(ext); + } + }); + }, + }; + var JSEvents = { + inEventHandler: 0, + removeAllEventListeners: function () { + for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) { + JSEvents._removeHandler(i); + } + JSEvents.eventHandlers = []; + JSEvents.deferredCalls = []; + }, + registerRemoveEventListeners: function () { + if (!JSEvents.removeEventListenersRegistered) { + __ATEXIT__.push(JSEvents.removeAllEventListeners); + JSEvents.removeEventListenersRegistered = true; + } + }, + deferredCalls: [], + deferCall: function (targetFunction, precedence, argsList) { + function arraysHaveEqualContent(arrA, arrB) { + if (arrA.length != arrB.length) return false; + for (var i in arrA) { + if (arrA[i] != arrB[i]) return false; + } + return true; + } + for (var i in JSEvents.deferredCalls) { + var call = JSEvents.deferredCalls[i]; + if ( + call.targetFunction == targetFunction && + arraysHaveEqualContent(call.argsList, argsList) + ) { + return; + } + } + JSEvents.deferredCalls.push({ + targetFunction: targetFunction, + precedence: precedence, + argsList: argsList, + }); + JSEvents.deferredCalls.sort(function (x, y) { + return x.precedence < y.precedence; + }); + }, + removeDeferredCalls: function (targetFunction) { + for (var i = 0; i < JSEvents.deferredCalls.length; ++i) { + if (JSEvents.deferredCalls[i].targetFunction == targetFunction) { + JSEvents.deferredCalls.splice(i, 1); + --i; + } + } + }, + canPerformEventHandlerRequests: function () { + return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls; + }, + runDeferredCalls: function () { + if (!JSEvents.canPerformEventHandlerRequests()) { + return; + } + for (var i = 0; i < JSEvents.deferredCalls.length; ++i) { + var call = JSEvents.deferredCalls[i]; + JSEvents.deferredCalls.splice(i, 1); + --i; + call.targetFunction.apply(null, call.argsList); + } + }, + eventHandlers: [], + removeAllHandlersOnTarget: function (target, eventTypeString) { + for (var i = 0; i < JSEvents.eventHandlers.length; ++i) { + if ( + JSEvents.eventHandlers[i].target == target && + (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString) + ) { + JSEvents._removeHandler(i--); + } + } + }, + _removeHandler: function (i) { + var h = JSEvents.eventHandlers[i]; + h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture); + JSEvents.eventHandlers.splice(i, 1); + }, + registerOrRemoveHandler: function (eventHandler) { + var jsEventHandler = function jsEventHandler(event) { + ++JSEvents.inEventHandler; + JSEvents.currentEventHandler = eventHandler; + JSEvents.runDeferredCalls(); + eventHandler.handlerFunc(event); + JSEvents.runDeferredCalls(); + --JSEvents.inEventHandler; + }; + if (eventHandler.callbackfunc) { + eventHandler.eventListenerFunc = jsEventHandler; + eventHandler.target.addEventListener( + eventHandler.eventTypeString, + jsEventHandler, + eventHandler.useCapture, + ); + JSEvents.eventHandlers.push(eventHandler); + JSEvents.registerRemoveEventListeners(); + } else { + for (var i = 0; i < JSEvents.eventHandlers.length; ++i) { + if ( + JSEvents.eventHandlers[i].target == eventHandler.target && + JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString + ) { + JSEvents._removeHandler(i--); + } + } + } + }, + getNodeNameForTarget: function (target) { + if (!target) return ""; + if (target == window) return "#window"; + if (target == screen) return "#screen"; + return target && target.nodeName ? target.nodeName : ""; + }, + fullscreenEnabled: function () { + return document.fullscreenEnabled || document.webkitFullscreenEnabled; + }, + }; + var __emscripten_webgl_power_preferences = ["default", "low-power", "high-performance"]; + var specialHTMLTargets = [ + 0, + typeof document != "undefined" ? document : 0, + typeof window != "undefined" ? window : 0, + ]; + function findEventTarget(target) { + warnOnce( + "Rules for selecting event targets in HTML5 API are changing: instead of using document.getElementById() that only can refer to elements by their DOM ID, new event target selection mechanism uses the more flexible function document.querySelector() that can look up element names, classes, and complex CSS selectors. Build with -sDISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR to change to the new lookup rules. See https://github.com/emscripten-core/emscripten/pull/7977 for more details.", + ); + try { + if (!target) return window; + if (typeof target == "number") target = specialHTMLTargets[target] || UTF8ToString(target); + if (target === "#window") return window; + else if (target === "#document") return document; + else if (target === "#screen") return screen; + else if (target === "#canvas") return Module["canvas"]; + return typeof target == "string" ? document.getElementById(target) : target; + } catch (e) { + return null; + } + } + function findCanvasEventTarget(target) { + if (typeof target == "number") target = UTF8ToString(target); + if (!target || target === "#canvas") { + if (typeof GL != "undefined" && GL.offscreenCanvases["canvas"]) + return GL.offscreenCanvases["canvas"]; + return Module["canvas"]; + } + if (typeof GL != "undefined" && GL.offscreenCanvases[target]) + return GL.offscreenCanvases[target]; + return findEventTarget(target); + } + function _emscripten_webgl_do_create_context(target, attributes) { + assert(attributes); + var a = attributes >> 2; + var powerPreference = HEAP32[a + (24 >> 2)]; + var contextAttributes = { + alpha: !!HEAP32[a + (0 >> 2)], + depth: !!HEAP32[a + (4 >> 2)], + stencil: !!HEAP32[a + (8 >> 2)], + antialias: !!HEAP32[a + (12 >> 2)], + premultipliedAlpha: !!HEAP32[a + (16 >> 2)], + preserveDrawingBuffer: !!HEAP32[a + (20 >> 2)], + powerPreference: __emscripten_webgl_power_preferences[powerPreference], + failIfMajorPerformanceCaveat: !!HEAP32[a + (28 >> 2)], + majorVersion: HEAP32[a + (32 >> 2)], + minorVersion: HEAP32[a + (36 >> 2)], + enableExtensionsByDefault: HEAP32[a + (40 >> 2)], + explicitSwapControl: HEAP32[a + (44 >> 2)], + proxyContextToMainThread: HEAP32[a + (48 >> 2)], + renderViaOffscreenBackBuffer: HEAP32[a + (52 >> 2)], + }; + var canvas = findCanvasEventTarget(target); + if (!canvas) { + return 0; + } + if (canvas.offscreenCanvas) canvas = canvas.offscreenCanvas; + if (contextAttributes.explicitSwapControl) { + var supportsOffscreenCanvas = + canvas.transferControlToOffscreen || + (typeof OffscreenCanvas != "undefined" && canvas instanceof OffscreenCanvas); + if (!supportsOffscreenCanvas) { + if (!contextAttributes.renderViaOffscreenBackBuffer) { + contextAttributes.renderViaOffscreenBackBuffer = true; + } + } + if (canvas.transferControlToOffscreen) { + if (!canvas.controlTransferredOffscreen) { + GL.offscreenCanvases[canvas.id] = { + canvas: canvas.transferControlToOffscreen(), + canvasSharedPtr: _malloc(12), + id: canvas.id, + }; + canvas.controlTransferredOffscreen = true; + } else if (!GL.offscreenCanvases[canvas.id]) { + return 0; + } + canvas = GL.offscreenCanvases[canvas.id]; + } + } + var contextHandle = GL.createContext(canvas, contextAttributes); + return contextHandle; + } + var _emscripten_webgl_create_context = _emscripten_webgl_do_create_context; + function _emscripten_webgl_destroy_context(contextHandle) { + if (GL.currentContext == contextHandle) GL.currentContext = 0; + GL.deleteContext(contextHandle); + } + function _emscripten_webgl_get_context_attributes(c, a) { + if (!a) return -5; + c = GL.contexts[c]; + if (!c) return -3; + var t = c.GLctx; + if (!t) return -3; + t = t.getContextAttributes(); + HEAP32[a >> 2] = t.alpha; + HEAP32[(a + 4) >> 2] = t.depth; + HEAP32[(a + 8) >> 2] = t.stencil; + HEAP32[(a + 12) >> 2] = t.antialias; + HEAP32[(a + 16) >> 2] = t.premultipliedAlpha; + HEAP32[(a + 20) >> 2] = t.preserveDrawingBuffer; + var power = + t["powerPreference"] && __emscripten_webgl_power_preferences.indexOf(t["powerPreference"]); + HEAP32[(a + 24) >> 2] = power; + HEAP32[(a + 28) >> 2] = t.failIfMajorPerformanceCaveat; + HEAP32[(a + 32) >> 2] = c.version; + HEAP32[(a + 36) >> 2] = 0; + HEAP32[(a + 40) >> 2] = c.attributes.enableExtensionsByDefault; + return 0; + } + function _emscripten_webgl_do_get_current_context() { + return GL.currentContext ? GL.currentContext.handle : 0; + } + var _emscripten_webgl_get_current_context = _emscripten_webgl_do_get_current_context; + function _emscripten_webgl_init_context_attributes(attributes) { + assert(attributes); + var a = attributes >> 2; + for (var i = 0; i < 56 >> 2; ++i) { + HEAP32[a + i] = 0; + } + HEAP32[a + (0 >> 2)] = + HEAP32[a + (4 >> 2)] = + HEAP32[a + (12 >> 2)] = + HEAP32[a + (16 >> 2)] = + HEAP32[a + (32 >> 2)] = + HEAP32[a + (40 >> 2)] = + 1; + } + function _emscripten_webgl_make_context_current(contextHandle) { + var success = GL.makeContextCurrent(contextHandle); + return success ? 0 : -5; + } + var WebGPU = { + initManagers: function () { + if (WebGPU.mgrDevice) return; + function Manager() { + this.objects = {}; + this.nextId = 1; + this.create = function (object, wrapper) { + wrapper = wrapper || {}; + var id = this.nextId++; + assert(typeof this.objects[id] == "undefined"); + wrapper.refcount = 1; + wrapper.object = object; + this.objects[id] = wrapper; + return id; + }; + this.get = function (id) { + if (!id) return undefined; + var o = this.objects[id]; + assert(typeof o != "undefined"); + return o.object; + }; + this.reference = function (id) { + var o = this.objects[id]; + assert(typeof o != "undefined"); + o.refcount++; + }; + this.release = function (id) { + var o = this.objects[id]; + assert(typeof o != "undefined"); + assert(o.refcount > 0); + o.refcount--; + if (o.refcount <= 0) { + delete this.objects[id]; + } + }; + } + WebGPU.mgrSurface = WebGPU.mgrSurface || new Manager(); + WebGPU.mgrSwapChain = WebGPU.mgrSwapChain || new Manager(); + WebGPU.mgrAdapter = WebGPU.mgrAdapter || new Manager(); + WebGPU.mgrDevice = WebGPU.mgrDevice || new Manager(); + WebGPU.mgrQueue = WebGPU.mgrQueue || new Manager(); + WebGPU.mgrCommandBuffer = WebGPU.mgrCommandBuffer || new Manager(); + WebGPU.mgrCommandEncoder = WebGPU.mgrCommandEncoder || new Manager(); + WebGPU.mgrRenderPassEncoder = WebGPU.mgrRenderPassEncoder || new Manager(); + WebGPU.mgrComputePassEncoder = WebGPU.mgrComputePassEncoder || new Manager(); + WebGPU.mgrBindGroup = WebGPU.mgrBindGroup || new Manager(); + WebGPU.mgrBuffer = WebGPU.mgrBuffer || new Manager(); + WebGPU.mgrSampler = WebGPU.mgrSampler || new Manager(); + WebGPU.mgrTexture = WebGPU.mgrTexture || new Manager(); + WebGPU.mgrTextureView = WebGPU.mgrTextureView || new Manager(); + WebGPU.mgrQuerySet = WebGPU.mgrQuerySet || new Manager(); + WebGPU.mgrBindGroupLayout = WebGPU.mgrBindGroupLayout || new Manager(); + WebGPU.mgrPipelineLayout = WebGPU.mgrPipelineLayout || new Manager(); + WebGPU.mgrRenderPipeline = WebGPU.mgrRenderPipeline || new Manager(); + WebGPU.mgrComputePipeline = WebGPU.mgrComputePipeline || new Manager(); + WebGPU.mgrShaderModule = WebGPU.mgrShaderModule || new Manager(); + WebGPU.mgrRenderBundleEncoder = WebGPU.mgrRenderBundleEncoder || new Manager(); + WebGPU.mgrRenderBundle = WebGPU.mgrRenderBundle || new Manager(); + }, + makeColor: function (ptr) { + return { + r: HEAPF64[ptr >> 3], + g: HEAPF64[(ptr + 8) >> 3], + b: HEAPF64[(ptr + 16) >> 3], + a: HEAPF64[(ptr + 24) >> 3], + }; + }, + makeExtent3D: function (ptr) { + return { + width: HEAPU32[ptr >> 2], + height: HEAPU32[(ptr + 4) >> 2], + depthOrArrayLayers: HEAPU32[(ptr + 8) >> 2], + }; + }, + makeOrigin3D: function (ptr) { + return { x: HEAPU32[ptr >> 2], y: HEAPU32[(ptr + 4) >> 2], z: HEAPU32[(ptr + 8) >> 2] }; + }, + makeImageCopyTexture: function (ptr) { + assert(ptr); + assert(HEAPU32[ptr >> 2] === 0); + return { + texture: WebGPU.mgrTexture.get(HEAPU32[(ptr + 4) >> 2]), + mipLevel: HEAPU32[(ptr + 8) >> 2], + origin: WebGPU.makeOrigin3D(ptr + 12), + aspect: WebGPU.TextureAspect[HEAPU32[(ptr + 24) >> 2]], + }; + }, + makeTextureDataLayout: function (ptr) { + assert(ptr); + assert(HEAPU32[ptr >> 2] === 0); + var bytesPerRow = HEAPU32[(ptr + 16) >> 2]; + var rowsPerImage = HEAPU32[(ptr + 20) >> 2]; + return { + offset: HEAPU32[(ptr + 4 + 8) >> 2] * 4294967296 + HEAPU32[(ptr + 8) >> 2], + bytesPerRow: bytesPerRow === 4294967295 ? undefined : bytesPerRow, + rowsPerImage: rowsPerImage === 4294967295 ? undefined : rowsPerImage, + }; + }, + makeImageCopyBuffer: function (ptr) { + assert(ptr); + assert(HEAPU32[ptr >> 2] === 0); + var layoutPtr = ptr + 8; + var bufferCopyView = WebGPU.makeTextureDataLayout(layoutPtr); + bufferCopyView["buffer"] = WebGPU.mgrBuffer.get(HEAPU32[(ptr + 32) >> 2]); + return bufferCopyView; + }, + makePipelineConstants: function (constantCount, constantsPtr) { + if (!constantCount) return; + var constants = {}; + for (var i = 0; i < constantCount; ++i) { + var entryPtr = constantsPtr + 16 * i; + var key = UTF8ToString(HEAPU32[(entryPtr + 4) >> 2]); + constants[key] = HEAPF64[(entryPtr + 8) >> 3]; + } + return constants; + }, + makeProgrammableStageDescriptor: function (ptr) { + if (!ptr) return undefined; + assert(ptr); + assert(HEAPU32[ptr >> 2] === 0); + return { + module: WebGPU.mgrShaderModule.get(HEAPU32[(ptr + 4) >> 2]), + entryPoint: UTF8ToString(HEAPU32[(ptr + 8) >> 2]), + constants: WebGPU.makePipelineConstants( + HEAPU32[(ptr + 12) >> 2], + HEAPU32[(ptr + 16) >> 2], + ), + }; + }, + DeviceLostReason: { undefined: 0, destroyed: 1 }, + PreferredFormat: { rgba8unorm: 18, bgra8unorm: 23 }, + AddressMode: ["repeat", "mirror-repeat", "clamp-to-edge"], + BlendFactor: [ + "zero", + "one", + "src", + "one-minus-src", + "src-alpha", + "one-minus-src-alpha", + "dst", + "one-minus-dst", + "dst-alpha", + "one-minus-dst-alpha", + "src-alpha-saturated", + "constant", + "one-minus-constant", + ], + BlendOperation: ["add", "subtract", "reverse-subtract", "min", "max"], + BufferBindingType: [, "uniform", "storage", "read-only-storage"], + CompareFunction: [ + , + "never", + "less", + "less-equal", + "greater", + "greater-equal", + "equal", + "not-equal", + "always", + ], + CompilationInfoRequestStatus: ["success", "error", "device-lost", "unknown"], + ComputePassTimestampLocation: ["beginning", "end"], + CullMode: ["none", "front", "back"], + ErrorFilter: ["validation", "out-of-memory"], + FeatureName: [ + , + "depth-clip-control", + "depth32float-stencil8", + "timestamp-query", + "pipeline-statistics-query", + "texture-compression-bc", + "texture-compression-etc2", + "texture-compression-astc", + "indirect-first-instance", + ], + FilterMode: ["nearest", "linear"], + FrontFace: ["ccw", "cw"], + IndexFormat: [, "uint16", "uint32"], + LoadOp: [, "clear", "load"], + PipelineStatisticName: [ + "vertex-shader-invocations", + "clipper-invocations", + "clipper-primitives-out", + "fragment-shader-invocations", + "compute-shader-invocations", + ], + PowerPreference: [, "low-power", "high-performance"], + PrimitiveTopology: [ + "point-list", + "line-list", + "line-strip", + "triangle-list", + "triangle-strip", + ], + QueryType: ["occlusion", "pipeline-statistics", "timestamp"], + RenderPassTimestampLocation: ["beginning", "end"], + SamplerBindingType: [, "filtering", "non-filtering", "comparison"], + StencilOperation: [ + "keep", + "zero", + "replace", + "invert", + "increment-clamp", + "decrement-clamp", + "increment-wrap", + "decrement-wrap", + ], + StorageTextureAccess: [, "write-only"], + StoreOp: [, "store", "discard"], + TextureAspect: ["all", "stencil-only", "depth-only"], + TextureComponentType: ["float", "sint", "uint", "depth-comparison"], + TextureDimension: ["1d", "2d", "3d"], + TextureFormat: [ + , + "r8unorm", + "r8snorm", + "r8uint", + "r8sint", + "r16uint", + "r16sint", + "r16float", + "rg8unorm", + "rg8snorm", + "rg8uint", + "rg8sint", + "r32float", + "r32uint", + "r32sint", + "rg16uint", + "rg16sint", + "rg16float", + "rgba8unorm", + "rgba8unorm-srgb", + "rgba8snorm", + "rgba8uint", + "rgba8sint", + "bgra8unorm", + "bgra8unorm-srgb", + "rgb10a2unorm", + "rg11b10ufloat", + "rgb9e5ufloat", + "rg32float", + "rg32uint", + "rg32sint", + "rgba16uint", + "rgba16sint", + "rgba16float", + "rgba32float", + "rgba32uint", + "rgba32sint", + "stencil8", + "depth16unorm", + "depth24plus", + "depth24plus-stencil8", + "depth32float", + "depth32float-stencil8", + "bc1-rgba-unorm", + "bc1-rgba-unorm-srgb", + "bc2-rgba-unorm", + "bc2-rgba-unorm-srgb", + "bc3-rgba-unorm", + "bc3-rgba-unorm-srgb", + "bc4-r-unorm", + "bc4-r-snorm", + "bc5-rg-unorm", + "bc5-rg-snorm", + "bc6h-rgb-ufloat", + "bc6h-rgb-float", + "bc7-rgba-unorm", + "bc7-rgba-unorm-srgb", + "etc2-rgb8unorm", + "etc2-rgb8unorm-srgb", + "etc2-rgb8a1unorm", + "etc2-rgb8a1unorm-srgb", + "etc2-rgba8unorm", + "etc2-rgba8unorm-srgb", + "eac-r11unorm", + "eac-r11snorm", + "eac-rg11unorm", + "eac-rg11snorm", + "astc-4x4-unorm", + "astc-4x4-unorm-srgb", + "astc-5x4-unorm", + "astc-5x4-unorm-srgb", + "astc-5x5-unorm", + "astc-5x5-unorm-srgb", + "astc-6x5-unorm", + "astc-6x5-unorm-srgb", + "astc-6x6-unorm", + "astc-6x6-unorm-srgb", + "astc-8x5-unorm", + "astc-8x5-unorm-srgb", + "astc-8x6-unorm", + "astc-8x6-unorm-srgb", + "astc-8x8-unorm", + "astc-8x8-unorm-srgb", + "astc-10x5-unorm", + "astc-10x5-unorm-srgb", + "astc-10x6-unorm", + "astc-10x6-unorm-srgb", + "astc-10x8-unorm", + "astc-10x8-unorm-srgb", + "astc-10x10-unorm", + "astc-10x10-unorm-srgb", + "astc-12x10-unorm", + "astc-12x10-unorm-srgb", + "astc-12x12-unorm", + "astc-12x12-unorm-srgb", + ], + TextureSampleType: [, "float", "unfilterable-float", "depth", "sint", "uint"], + TextureViewDimension: [, "1d", "2d", "2d-array", "cube", "cube-array", "3d"], + VertexFormat: [ + , + "uint8x2", + "uint8x4", + "sint8x2", + "sint8x4", + "unorm8x2", + "unorm8x4", + "snorm8x2", + "snorm8x4", + "uint16x2", + "uint16x4", + "sint16x2", + "sint16x4", + "unorm16x2", + "unorm16x4", + "snorm16x2", + "snorm16x4", + "float16x2", + "float16x4", + "float32", + "float32x2", + "float32x3", + "float32x4", + "uint32", + "uint32x2", + "uint32x3", + "uint32x4", + "sint32", + "sint32x2", + "sint32x3", + "sint32x4", + ], + VertexStepMode: ["vertex", "instance"], + FeatureNameString2Enum: { + undefined: "0", + "depth-clip-control": "1", + "depth32float-stencil8": "2", + "timestamp-query": "3", + "pipeline-statistics-query": "4", + "texture-compression-bc": "5", + "texture-compression-etc2": "6", + "texture-compression-astc": "7", + "indirect-first-instance": "8", + }, + }; + var JsValStore = { + values: {}, + next_id: 1, + add: function (js_val) { + var id; + do { + id = JsValStore.next_id++; + if (JsValStore.next_id > 2147483647) JsValStore.next_id = 1; + } while (id in JsValStore.values); + JsValStore.values[id] = js_val; + return id; + }, + remove: function (id) { + assert(id in JsValStore.values); + delete JsValStore.values[id]; + }, + get: function (id) { + assert(id === 0 || id in JsValStore.values); + return JsValStore.values[id]; + }, + }; + function _emscripten_webgpu_export_bind_group_layout(handle) { + return JsValStore.add(WebGPU.mgrBindGroupLayout.get(handle)); + } + function _emscripten_webgpu_export_device(handle) { + return JsValStore.add(WebGPU.mgrDevice.get(handle)); + } + function _emscripten_webgpu_export_sampler(handle) { + return JsValStore.add(WebGPU.mgrSampler.get(handle)); + } + function _emscripten_webgpu_export_texture(handle) { + return JsValStore.add(WebGPU.mgrTexture.get(handle)); + } + function _emscripten_webgpu_get_device() { + assert(Module["preinitializedWebGPUDevice"]); + if (WebGPU.preinitializedDeviceId === undefined) { + var device = Module["preinitializedWebGPUDevice"]; + var deviceWrapper = { queueId: WebGPU.mgrQueue.create(device["queue"]) }; + WebGPU.preinitializedDeviceId = WebGPU.mgrDevice.create(device, deviceWrapper); + } + WebGPU.mgrDevice.reference(WebGPU.preinitializedDeviceId); + return WebGPU.preinitializedDeviceId; + } + function _emscripten_webgpu_import_bind_group(handle) { + return WebGPU.mgrBindGroup.create(JsValStore.get(handle)); + } + function _emscripten_webgpu_import_texture(handle) { + return WebGPU.mgrTexture.create(JsValStore.get(handle)); + } + function _emscripten_webgpu_release_js_handle(id) { + JsValStore.remove(id); + } + var ENV = {}; + function getExecutableName() { + return thisProgram || "./this.program"; + } + function getEnvStrings() { + if (!getEnvStrings.strings) { + var lang = + ( + (typeof navigator == "object" && navigator.languages && navigator.languages[0]) || + "C" + ).replace("-", "_") + ".UTF-8"; + var env = { + USER: "web_user", + LOGNAME: "web_user", + PATH: "/", + PWD: "/", + HOME: "/home/web_user", + LANG: lang, + _: getExecutableName(), + }; + for (var x in ENV) { + if (ENV[x] === undefined) delete env[x]; + else env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + "=" + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + } + function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + assert(str.charCodeAt(i) === (str.charCodeAt(i) & 255)); + HEAP8[buffer++ >> 0] = str.charCodeAt(i); + } + if (!dontAddNull) HEAP8[buffer >> 0] = 0; + } + function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function (string, i) { + var ptr = environ_buf + bufSize; + HEAPU32[(__environ + i * 4) >> 2] = ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1; + }); + return 0; + } + function _environ_sizes_get(penviron_count, penviron_buf_size) { + var strings = getEnvStrings(); + HEAPU32[penviron_count >> 2] = strings.length; + var bufSize = 0; + strings.forEach(function (string) { + bufSize += string.length + 1; + }); + HEAPU32[penviron_buf_size >> 2] = bufSize; + return 0; + } + function _fd_close(fd) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + function doReadv(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[iov >> 2]; + var len = HEAPU32[(iov + 4) >> 2]; + iov += 8; + var curr = FS.read(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; + } + return ret; + } + function _fd_read(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAPU32[pnum >> 2] = num; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + function convertI32PairToI53Checked(lo, hi) { + assert(lo == lo >>> 0 || lo == (lo | 0)); + assert(hi === (hi | 0)); + return (hi + 2097152) >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN; + } + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + var offset = convertI32PairToI53Checked(offset_low, offset_high); + if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + (tempI64 = [ + stream.position >>> 0, + ((tempDouble = stream.position), + +Math.abs(tempDouble) >= 1 + ? tempDouble > 0 + ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 + : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 + : 0), + ]), + (HEAP32[newOffset >> 2] = tempI64[0]), + (HEAP32[(newOffset + 4) >> 2] = tempI64[1]); + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + function doWritev(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[iov >> 2]; + var len = HEAPU32[(iov + 4) >> 2]; + iov += 8; + var curr = FS.write(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + } + return ret; + } + function _fd_write(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[pnum >> 2] = num; + return 0; + } catch (e) { + if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e; + return e.errno; + } + } + function _getentropy(buffer, size) { + if (!_getentropy.randomDevice) { + _getentropy.randomDevice = getRandomDevice(); + } + for (var i = 0; i < size; i++) { + HEAP8[(buffer + i) >> 0] = _getentropy.randomDevice(); + } + return 0; + } + function _glActiveTexture(x0) { + GLctx["activeTexture"](x0); + } + function _glAttachShader(program, shader) { + GLctx.attachShader(GL.programs[program], GL.shaders[shader]); + } + function _glBindAttribLocation(program, index, name) { + GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name)); + } + function _glBindBuffer(target, buffer) { + if (target == 34962) { + GLctx.currentArrayBufferBinding = buffer; + } else if (target == 34963) { + GLctx.currentElementArrayBufferBinding = buffer; + } + if (target == 35051) { + GLctx.currentPixelPackBufferBinding = buffer; + } else if (target == 35052) { + GLctx.currentPixelUnpackBufferBinding = buffer; + } + GLctx.bindBuffer(target, GL.buffers[buffer]); + } + function _glBindBufferBase(target, index, buffer) { + GLctx["bindBufferBase"](target, index, GL.buffers[buffer]); + } + function _glBindFramebuffer(target, framebuffer) { + GLctx.bindFramebuffer( + target, + framebuffer ? GL.framebuffers[framebuffer] : GL.currentContext.defaultFbo, + ); + } + function _glBindTexture(target, texture) { + GLctx.bindTexture(target, GL.textures[texture]); + } + function _glBindVertexArray(vao) { + GLctx["bindVertexArray"](GL.vaos[vao]); + var ibo = GLctx.getParameter(34965); + GLctx.currentElementArrayBufferBinding = ibo ? ibo.name | 0 : 0; + } + function _glBufferData(target, size, data, usage) { + if (GL.currentContext.version >= 2) { + if (data && size) { + GLctx.bufferData(target, HEAPU8, usage, data, size); + } else { + GLctx.bufferData(target, size, usage); + } + } else { + GLctx.bufferData(target, data ? HEAPU8.subarray(data, data + size) : size, usage); + } + } + function convertI32PairToI53(lo, hi) { + assert(hi === (hi | 0)); + return (lo >>> 0) + hi * 4294967296; + } + function _glClientWaitSync(sync, flags, timeoutLo, timeoutHi) { + return GLctx.clientWaitSync(GL.syncs[sync], flags, convertI32PairToI53(timeoutLo, timeoutHi)); + } + function _glCompileShader(shader) { + GLctx.compileShader(GL.shaders[shader]); + } + function _glCreateProgram() { + var id = GL.getNewId(GL.programs); + var program = GLctx.createProgram(); + program.name = id; + program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0; + program.uniformIdCounter = 1; + GL.programs[id] = program; + return id; + } + function _glCreateShader(shaderType) { + var id = GL.getNewId(GL.shaders); + GL.shaders[id] = GLctx.createShader(shaderType); + return id; + } + function _glDeleteBuffers(n, buffers) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(buffers + i * 4) >> 2]; + var buffer = GL.buffers[id]; + if (!buffer) continue; + GLctx.deleteBuffer(buffer); + buffer.name = 0; + GL.buffers[id] = null; + if (id == GLctx.currentArrayBufferBinding) GLctx.currentArrayBufferBinding = 0; + if (id == GLctx.currentElementArrayBufferBinding) + GLctx.currentElementArrayBufferBinding = 0; + if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0; + if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0; + } + } + function _glDeleteFramebuffers(n, framebuffers) { + for (var i = 0; i < n; ++i) { + var id = HEAP32[(framebuffers + i * 4) >> 2]; + var framebuffer = GL.framebuffers[id]; + if (!framebuffer) continue; + GLctx.deleteFramebuffer(framebuffer); + framebuffer.name = 0; + GL.framebuffers[id] = null; + } + } + function _glDeleteProgram(id) { + if (!id) return; + var program = GL.programs[id]; + if (!program) { + GL.recordError(1281); + return; + } + GLctx.deleteProgram(program); + program.name = 0; + GL.programs[id] = null; + } + function _glDeleteShader(id) { + if (!id) return; + var shader = GL.shaders[id]; + if (!shader) { + GL.recordError(1281); + return; + } + GLctx.deleteShader(shader); + GL.shaders[id] = null; + } + function _glDeleteSync(id) { + if (!id) return; + var sync = GL.syncs[id]; + if (!sync) { + GL.recordError(1281); + return; + } + GLctx.deleteSync(sync); + sync.name = 0; + GL.syncs[id] = null; + } + function _glDeleteTextures(n, textures) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(textures + i * 4) >> 2]; + var texture = GL.textures[id]; + if (!texture) continue; + GLctx.deleteTexture(texture); + texture.name = 0; + GL.textures[id] = null; + } + } + function _glDeleteVertexArrays(n, vaos) { + for (var i = 0; i < n; i++) { + var id = HEAP32[(vaos + i * 4) >> 2]; + GLctx["deleteVertexArray"](GL.vaos[id]); + GL.vaos[id] = null; + } + } + function _glDisable(x0) { + GLctx["disable"](x0); + } + function _glDisableVertexAttribArray(index) { + var cb = GL.currentContext.clientBuffers[index]; + cb.enabled = false; + GLctx.disableVertexAttribArray(index); + } + function _glDrawArrays(mode, first, count) { + GL.preDrawHandleClientVertexAttribBindings(first + count); + GLctx.drawArrays(mode, first, count); + GL.postDrawHandleClientVertexAttribBindings(); + } + var tempFixedLengthArray = []; + function _glDrawBuffers(n, bufs) { + var bufArray = tempFixedLengthArray[n]; + for (var i = 0; i < n; i++) { + bufArray[i] = HEAP32[(bufs + i * 4) >> 2]; + } + GLctx["drawBuffers"](bufArray); + } + function _glEnableVertexAttribArray(index) { + var cb = GL.currentContext.clientBuffers[index]; + cb.enabled = true; + GLctx.enableVertexAttribArray(index); + } + function _glFenceSync(condition, flags) { + var sync = GLctx.fenceSync(condition, flags); + if (sync) { + var id = GL.getNewId(GL.syncs); + sync.name = id; + GL.syncs[id] = sync; + return id; + } + return 0; + } + function _glFinish() { + GLctx["finish"](); + } + function _glFlush() { + GLctx["flush"](); + } + function _glFramebufferTexture2D(target, attachment, textarget, texture, level) { + GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level); + } + function _glFramebufferTextureLayer(target, attachment, texture, level, layer) { + GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer); + } + function __glGenObject(n, buffers, createFunction, objectTable) { + for (var i = 0; i < n; i++) { + var buffer = GLctx[createFunction](); + var id = buffer && GL.getNewId(objectTable); + if (buffer) { + buffer.name = id; + objectTable[id] = buffer; + } else { + GL.recordError(1282); + } + HEAP32[(buffers + i * 4) >> 2] = id; + } + } + function _glGenBuffers(n, buffers) { + __glGenObject(n, buffers, "createBuffer", GL.buffers); + } + function _glGenFramebuffers(n, ids) { + __glGenObject(n, ids, "createFramebuffer", GL.framebuffers); + } + function _glGenTextures(n, textures) { + __glGenObject(n, textures, "createTexture", GL.textures); + } + function _glGenVertexArrays(n, arrays) { + __glGenObject(n, arrays, "createVertexArray", GL.vaos); + } + function _glGetAttribLocation(program, name) { + return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name)); + } + function _glGetError() { + var error = GLctx.getError() || GL.lastError; + GL.lastError = 0; + return error; + } + function readI53FromU64(ptr) { + return HEAPU32[ptr >> 2] + HEAPU32[(ptr + 4) >> 2] * 4294967296; + } + function writeI53ToI64(ptr, num) { + HEAPU32[ptr >> 2] = num; + HEAPU32[(ptr + 4) >> 2] = (num - HEAPU32[ptr >> 2]) / 4294967296; + var deserialized = num >= 0 ? readI53FromU64(ptr) : readI53FromI64(ptr); + if (deserialized != num) + warnOnce( + "writeI53ToI64() out of range: serialized JS Number " + + num + + " to Wasm heap as bytes lo=" + + ptrToString(HEAPU32[ptr >> 2]) + + ", hi=" + + ptrToString(HEAPU32[(ptr + 4) >> 2]) + + ", which deserializes back to " + + deserialized + + " instead!", + ); + } + function emscriptenWebGLGet(name_, p, type) { + if (!p) { + GL.recordError(1281); + return; + } + var ret = undefined; + switch (name_) { + case 36346: + ret = 1; + break; + case 36344: + if (type != 0 && type != 1) { + GL.recordError(1280); + } + return; + case 34814: + case 36345: + ret = 0; + break; + case 34466: { + var formats = GLctx.getParameter(34467); + ret = formats ? formats.length : 0; + break; + } + case 33309: { + if (GL.currentContext.version < 2) { + GL.recordError(1282); + return; + } + var exts = GLctx.getSupportedExtensions() || []; + ret = 2 * exts.length; + break; + } + case 33307: + case 33308: + if (GL.currentContext.version < 2) { + GL.recordError(1280); + return; + } + ret = name_ == 33307 ? 3 : 0; + break; + } + if (ret === undefined) { + var result = GLctx.getParameter(name_); + switch (typeof result) { + case "number": + ret = result; + break; + case "boolean": + ret = result ? 1 : 0; + break; + case "string": + GL.recordError(1280); + return; + case "object": + if (result === null) { + switch (name_) { + case 34964: + case 35725: + case 34965: + case 36006: + case 36007: + case 32873: + case 34229: + case 36662: + case 36663: + case 35053: + case 35055: + case 36010: + case 35097: + case 35869: + case 32874: + case 36389: + case 35983: + case 35368: + case 34068: { + ret = 0; + break; + } + default: { + GL.recordError(1280); + return; + } + } + } else if ( + result instanceof Float32Array || + result instanceof Uint32Array || + result instanceof Int32Array || + result instanceof Array + ) { + for (var i = 0; i < result.length; ++i) { + switch (type) { + case 0: + HEAP32[(p + i * 4) >> 2] = result[i]; + break; + case 2: + HEAPF32[(p + i * 4) >> 2] = result[i]; + break; + case 4: + HEAP8[(p + i) >> 0] = result[i] ? 1 : 0; + break; + } + } + return; + } else { + try { + ret = result.name | 0; + } catch (e) { + GL.recordError(1280); + err( + "GL_INVALID_ENUM in glGet" + + type + + "v: Unknown object returned from WebGL getParameter(" + + name_ + + ")! (error: " + + e + + ")", + ); + return; + } + } + break; + default: + GL.recordError(1280); + err( + "GL_INVALID_ENUM in glGet" + + type + + "v: Native code calling glGet" + + type + + "v(" + + name_ + + ") and it returns " + + result + + " of type " + + typeof result + + "!", + ); + return; + } + } + switch (type) { + case 1: + writeI53ToI64(p, ret); + break; + case 0: + HEAP32[p >> 2] = ret; + break; + case 2: + HEAPF32[p >> 2] = ret; + break; + case 4: + HEAP8[p >> 0] = ret ? 1 : 0; + break; + } + } + function _glGetIntegerv(name_, p) { + emscriptenWebGLGet(name_, p, 0); + } + function _glGetProgramiv(program, pname, p) { + if (!p) { + GL.recordError(1281); + return; + } + if (program >= GL.counter) { + GL.recordError(1281); + return; + } + program = GL.programs[program]; + if (pname == 35716) { + var log = GLctx.getProgramInfoLog(program); + if (log === null) log = "(unknown error)"; + HEAP32[p >> 2] = log.length + 1; + } else if (pname == 35719) { + if (!program.maxUniformLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) { + program.maxUniformLength = Math.max( + program.maxUniformLength, + GLctx.getActiveUniform(program, i).name.length + 1, + ); + } + } + HEAP32[p >> 2] = program.maxUniformLength; + } else if (pname == 35722) { + if (!program.maxAttributeLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35721); ++i) { + program.maxAttributeLength = Math.max( + program.maxAttributeLength, + GLctx.getActiveAttrib(program, i).name.length + 1, + ); + } + } + HEAP32[p >> 2] = program.maxAttributeLength; + } else if (pname == 35381) { + if (!program.maxUniformBlockNameLength) { + for (var i = 0; i < GLctx.getProgramParameter(program, 35382); ++i) { + program.maxUniformBlockNameLength = Math.max( + program.maxUniformBlockNameLength, + GLctx.getActiveUniformBlockName(program, i).length + 1, + ); + } + } + HEAP32[p >> 2] = program.maxUniformBlockNameLength; + } else { + HEAP32[p >> 2] = GLctx.getProgramParameter(program, pname); + } + } + function _glGetShaderInfoLog(shader, maxLength, length, infoLog) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = "(unknown error)"; + var numBytesWrittenExclNull = + maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0; + if (length) HEAP32[length >> 2] = numBytesWrittenExclNull; + } + function _glGetShaderiv(shader, pname, p) { + if (!p) { + GL.recordError(1281); + return; + } + if (pname == 35716) { + var log = GLctx.getShaderInfoLog(GL.shaders[shader]); + if (log === null) log = "(unknown error)"; + var logLength = log ? log.length + 1 : 0; + HEAP32[p >> 2] = logLength; + } else if (pname == 35720) { + var source = GLctx.getShaderSource(GL.shaders[shader]); + var sourceLength = source ? source.length + 1 : 0; + HEAP32[p >> 2] = sourceLength; + } else { + HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname); + } + } + function stringToNewUTF8(jsString) { + var length = lengthBytesUTF8(jsString) + 1; + var cString = _malloc(length); + stringToUTF8(jsString, cString, length); + return cString; + } + function _glGetString(name_) { + var ret = GL.stringCache[name_]; + if (!ret) { + switch (name_) { + case 7939: { + var exts = GLctx.getSupportedExtensions() || []; + exts = exts.concat( + exts.map(function (e) { + return "GL_" + e; + }), + ); + ret = stringToNewUTF8(exts.join(" ")); + break; + } + case 7936: + case 7937: + case 37445: + case 37446: { + var s = GLctx.getParameter(name_); + if (!s) { + GL.recordError(1280); + } + ret = s && stringToNewUTF8(s); + break; + } + case 7938: { + var glVersion = GLctx.getParameter(7938); + if (GL.currentContext.version >= 2) glVersion = "OpenGL ES 3.0 (" + glVersion + ")"; + else { + glVersion = "OpenGL ES 2.0 (" + glVersion + ")"; + } + ret = stringToNewUTF8(glVersion); + break; + } + case 35724: { + var glslVersion = GLctx.getParameter(35724); + var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/; + var ver_num = glslVersion.match(ver_re); + if (ver_num !== null) { + if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0"; + glslVersion = "OpenGL ES GLSL ES " + ver_num[1] + " (" + glslVersion + ")"; + } + ret = stringToNewUTF8(glslVersion); + break; + } + default: + GL.recordError(1280); + } + GL.stringCache[name_] = ret; + } + return ret; + } + function _glGetUniformBlockIndex(program, uniformBlockName) { + return GLctx["getUniformBlockIndex"](GL.programs[program], UTF8ToString(uniformBlockName)); + } + function jstoi_q(str) { + return parseInt(str); + } + function webglGetLeftBracePos(name) { + return name.slice(-1) == "]" && name.lastIndexOf("["); + } + function webglPrepareUniformLocationsBeforeFirstUse(program) { + var uniformLocsById = program.uniformLocsById, + uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, + i, + j; + if (!uniformLocsById) { + program.uniformLocsById = uniformLocsById = {}; + program.uniformArrayNamesById = {}; + for (i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) { + var u = GLctx.getActiveUniform(program, i); + var nm = u.name; + var sz = u.size; + var lb = webglGetLeftBracePos(nm); + var arrayName = lb > 0 ? nm.slice(0, lb) : nm; + var id = program.uniformIdCounter; + program.uniformIdCounter += sz; + uniformSizeAndIdsByName[arrayName] = [sz, id]; + for (j = 0; j < sz; ++j) { + uniformLocsById[id] = j; + program.uniformArrayNamesById[id++] = arrayName; + } + } + } + } + function _glGetUniformLocation(program, name) { + name = UTF8ToString(name); + if ((program = GL.programs[program])) { + webglPrepareUniformLocationsBeforeFirstUse(program); + var uniformLocsById = program.uniformLocsById; + var arrayIndex = 0; + var uniformBaseName = name; + var leftBrace = webglGetLeftBracePos(name); + if (leftBrace > 0) { + arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0; + uniformBaseName = name.slice(0, leftBrace); + } + var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName]; + if (sizeAndId && arrayIndex < sizeAndId[0]) { + arrayIndex += sizeAndId[1]; + if ( + (uniformLocsById[arrayIndex] = + uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) + ) { + return arrayIndex; + } + } + } else { + GL.recordError(1281); + } + return -1; + } + function _glLinkProgram(program) { + program = GL.programs[program]; + GLctx.linkProgram(program); + program.uniformLocsById = 0; + program.uniformSizeAndIdsByName = {}; + } + function _glPixelStorei(pname, param) { + if (pname == 3317) { + GL.unpackAlignment = param; + } + GLctx.pixelStorei(pname, param); + } + function computeUnpackAlignedImageSize(width, height, sizePerPixel, alignment) { + function roundedToNextMultipleOf(x, y) { + return (x + y - 1) & -y; + } + var plainRowSize = width * sizePerPixel; + var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment); + return height * alignedRowSize; + } + function __colorChannelsInGlTextureFormat(format) { + var colorChannels = { + 5: 3, + 6: 4, + 8: 2, + 29502: 3, + 29504: 4, + 26917: 2, + 26918: 2, + 29846: 3, + 29847: 4, + }; + return colorChannels[format - 6402] || 1; + } + function heapObjectForWebGLType(type) { + type -= 5120; + if (type == 0) return HEAP8; + if (type == 1) return HEAPU8; + if (type == 2) return HEAP16; + if (type == 4) return HEAP32; + if (type == 6) return HEAPF32; + if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) + return HEAPU32; + return HEAPU16; + } + function heapAccessShiftForWebGLHeap(heap) { + return 31 - Math.clz32(heap.BYTES_PER_ELEMENT); + } + function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) { + var heap = heapObjectForWebGLType(type); + var shift = heapAccessShiftForWebGLHeap(heap); + var byteSize = 1 << shift; + var sizePerPixel = __colorChannelsInGlTextureFormat(format) * byteSize; + var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel, GL.unpackAlignment); + return heap.subarray(pixels >> shift, (pixels + bytes) >> shift); + } + function _glReadPixels(x, y, width, height, format, type, pixels) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelPackBufferBinding) { + GLctx.readPixels(x, y, width, height, format, type, pixels); + } else { + var heap = heapObjectForWebGLType(type); + GLctx.readPixels( + x, + y, + width, + height, + format, + type, + heap, + pixels >> heapAccessShiftForWebGLHeap(heap), + ); + } + return; + } + var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format); + if (!pixelData) { + GL.recordError(1280); + return; + } + GLctx.readPixels(x, y, width, height, format, type, pixelData); + } + function _glShaderSource(shader, count, string, length) { + var source = GL.getSource(shader, count, string, length); + GLctx.shaderSource(GL.shaders[shader], source); + } + function _glTexImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + pixels, + ) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + pixels, + ); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + heap, + pixels >> heapAccessShiftForWebGLHeap(heap), + ); + } else { + GLctx.texImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + null, + ); + } + return; + } + GLctx.texImage2D( + target, + level, + internalFormat, + width, + height, + border, + format, + type, + pixels + ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) + : null, + ); + } + function _glTexParameterfv(target, pname, params) { + var param = HEAPF32[params >> 2]; + GLctx.texParameterf(target, pname, param); + } + function _glTexParameteri(x0, x1, x2) { + GLctx["texParameteri"](x0, x1, x2); + } + function _glTexStorage2D(x0, x1, x2, x3, x4) { + GLctx["texStorage2D"](x0, x1, x2, x3, x4); + } + function _glTexStorage3D(x0, x1, x2, x3, x4, x5) { + GLctx["texStorage3D"](x0, x1, x2, x3, x4, x5); + } + function _glTexSubImage2D( + target, + level, + xoffset, + yoffset, + width, + height, + format, + type, + pixels, + ) { + if (GL.currentContext.version >= 2) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx.texSubImage2D( + target, + level, + xoffset, + yoffset, + width, + height, + format, + type, + heap, + pixels >> heapAccessShiftForWebGLHeap(heap), + ); + } else { + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, null); + } + return; + } + var pixelData = null; + if (pixels) + pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0); + GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData); + } + function _glTexSubImage3D( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type, + pixels, + ) { + if (GLctx.currentPixelUnpackBufferBinding) { + GLctx["texSubImage3D"]( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type, + pixels, + ); + } else if (pixels) { + var heap = heapObjectForWebGLType(type); + GLctx["texSubImage3D"]( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type, + heap, + pixels >> heapAccessShiftForWebGLHeap(heap), + ); + } else { + GLctx["texSubImage3D"]( + target, + level, + xoffset, + yoffset, + zoffset, + width, + height, + depth, + format, + type, + null, + ); + } + } + function webglGetUniformLocation(location) { + var p = GLctx.currentProgram; + if (p) { + var webglLoc = p.uniformLocsById[location]; + if (typeof webglLoc == "number") { + p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation( + p, + p.uniformArrayNamesById[location] + (webglLoc > 0 ? "[" + webglLoc + "]" : ""), + ); + } + return webglLoc; + } else { + GL.recordError(1282); + } + } + function _glUniform1f(location, v0) { + GLctx.uniform1f(webglGetUniformLocation(location), v0); + } + function _glUniform1i(location, v0) { + GLctx.uniform1i(webglGetUniformLocation(location), v0); + } + var miniTempWebGLFloatBuffers = []; + function _glUniform2fv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && + GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 2); + return; + } + if (count <= 144) { + var view = miniTempWebGLFloatBuffers[2 * count - 1]; + for (var i = 0; i < 2 * count; i += 2) { + view[i] = HEAPF32[(value + 4 * i) >> 2]; + view[i + 1] = HEAPF32[(value + (4 * i + 4)) >> 2]; + } + } else { + var view = HEAPF32.subarray(value >> 2, (value + count * 8) >> 2); + } + GLctx.uniform2fv(webglGetUniformLocation(location), view); + } + function _glUniform4fv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && + GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 4); + return; + } + if (count <= 72) { + var view = miniTempWebGLFloatBuffers[4 * count - 1]; + var heap = HEAPF32; + value >>= 2; + for (var i = 0; i < 4 * count; i += 4) { + var dst = value + i; + view[i] = heap[dst]; + view[i + 1] = heap[dst + 1]; + view[i + 2] = heap[dst + 2]; + view[i + 3] = heap[dst + 3]; + } + } else { + var view = HEAPF32.subarray(value >> 2, (value + count * 16) >> 2); + } + GLctx.uniform4fv(webglGetUniformLocation(location), view); + } + var __miniTempWebGLIntBuffers = []; + function _glUniform4iv(location, count, value) { + if (GL.currentContext.version >= 2) { + count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 4); + return; + } + if (count <= 72) { + var view = __miniTempWebGLIntBuffers[4 * count - 1]; + for (var i = 0; i < 4 * count; i += 4) { + view[i] = HEAP32[(value + 4 * i) >> 2]; + view[i + 1] = HEAP32[(value + (4 * i + 4)) >> 2]; + view[i + 2] = HEAP32[(value + (4 * i + 8)) >> 2]; + view[i + 3] = HEAP32[(value + (4 * i + 12)) >> 2]; + } + } else { + var view = HEAP32.subarray(value >> 2, (value + count * 16) >> 2); + } + GLctx.uniform4iv(webglGetUniformLocation(location), view); + } + function _glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) { + program = GL.programs[program]; + GLctx["uniformBlockBinding"](program, uniformBlockIndex, uniformBlockBinding); + } + function _glUniformMatrix4fv(location, count, transpose, value) { + if (GL.currentContext.version >= 2) { + count && + GLctx.uniformMatrix4fv( + webglGetUniformLocation(location), + !!transpose, + HEAPF32, + value >> 2, + count * 16, + ); + return; + } + if (count <= 18) { + var view = miniTempWebGLFloatBuffers[16 * count - 1]; + var heap = HEAPF32; + value >>= 2; + for (var i = 0; i < 16 * count; i += 16) { + var dst = value + i; + view[i] = heap[dst]; + view[i + 1] = heap[dst + 1]; + view[i + 2] = heap[dst + 2]; + view[i + 3] = heap[dst + 3]; + view[i + 4] = heap[dst + 4]; + view[i + 5] = heap[dst + 5]; + view[i + 6] = heap[dst + 6]; + view[i + 7] = heap[dst + 7]; + view[i + 8] = heap[dst + 8]; + view[i + 9] = heap[dst + 9]; + view[i + 10] = heap[dst + 10]; + view[i + 11] = heap[dst + 11]; + view[i + 12] = heap[dst + 12]; + view[i + 13] = heap[dst + 13]; + view[i + 14] = heap[dst + 14]; + view[i + 15] = heap[dst + 15]; + } + } else { + var view = HEAPF32.subarray(value >> 2, (value + count * 64) >> 2); + } + GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view); + } + function _glUseProgram(program) { + program = GL.programs[program]; + GLctx.useProgram(program); + GLctx.currentProgram = program; + } + function _glVertexAttribPointer(index, size, type, normalized, stride, ptr) { + var cb = GL.currentContext.clientBuffers[index]; + if (!GLctx.currentArrayBufferBinding) { + cb.size = size; + cb.type = type; + cb.normalized = normalized; + cb.stride = stride; + cb.ptr = ptr; + cb.clientside = true; + cb.vertexAttribPointerAdaptor = function (index, size, type, normalized, stride, ptr) { + this.vertexAttribPointer(index, size, type, normalized, stride, ptr); + }; + return; + } + cb.clientside = false; + GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr); + } + function _glViewport(x0, x1, x2, x3) { + GLctx["viewport"](x0, x1, x2, x3); + } + function _mediapipe_find_canvas_event_target(canvasSelector) { + return Emval.toHandle(findCanvasEventTarget(canvasSelector)); + } + function _mediapipe_webgl_tex_image_drawable(drawableHandle) { + const drawable = Emval.toValue(drawableHandle); + GLctx.texImage2D(GLctx.TEXTURE_2D, 0, GLctx.RGBA, GLctx.RGBA, GLctx.UNSIGNED_BYTE, drawable); + } + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) {} + return sum; + } + var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + if (days > daysInCurrentMonth - newDate.getDate()) { + days -= daysInCurrentMonth - newDate.getDate() + 1; + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth + 1); + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear() + 1); + } + } else { + newDate.setDate(newDate.getDate() + days); + return newDate; + } + } + return newDate; + } + function writeArrayToMemory(array, buffer) { + assert( + array.length >= 0, + "writeArrayToMemory array must have a length (should be an array or typed array)", + ); + HEAP8.set(array, buffer); + } + function _strftime(s, maxsize, format, tm) { + var tm_zone = HEAP32[(tm + 40) >> 2]; + var date = { + tm_sec: HEAP32[tm >> 2], + tm_min: HEAP32[(tm + 4) >> 2], + tm_hour: HEAP32[(tm + 8) >> 2], + tm_mday: HEAP32[(tm + 12) >> 2], + tm_mon: HEAP32[(tm + 16) >> 2], + tm_year: HEAP32[(tm + 20) >> 2], + tm_wday: HEAP32[(tm + 24) >> 2], + tm_yday: HEAP32[(tm + 28) >> 2], + tm_isdst: HEAP32[(tm + 32) >> 2], + tm_gmtoff: HEAP32[(tm + 36) >> 2], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : "", + }; + var pattern = UTF8ToString(format); + var EXPANSION_RULES_1 = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y", + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]); + } + var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]; + var MONTHS = [ + "January", + "February", + "March", + "April", + "May", + "June", + "July", + "August", + "September", + "October", + "November", + "December", + ]; + function leadingSomething(value, digits, character) { + var str = typeof value == "number" ? value.toString() : value || ""; + while (str.length < digits) { + str = character[0] + str; + } + return str; + } + function leadingNulls(value, digits) { + return leadingSomething(value, digits, "0"); + } + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : value > 0 ? 1 : 0; + } + var compare; + if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) { + compare = sgn(date1.getDate() - date2.getDate()); + } + } + return compare; + } + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: + return new Date(janFourth.getFullYear() - 1, 11, 29); + case 1: + return janFourth; + case 2: + return new Date(janFourth.getFullYear(), 0, 3); + case 3: + return new Date(janFourth.getFullYear(), 0, 2); + case 4: + return new Date(janFourth.getFullYear(), 0, 1); + case 5: + return new Date(janFourth.getFullYear() - 1, 11, 31); + case 6: + return new Date(janFourth.getFullYear() - 1, 11, 30); + } + } + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday); + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4); + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear() + 1; + } + return thisDate.getFullYear(); + } + return thisDate.getFullYear() - 1; + } + var EXPANSION_RULES_2 = { + "%a": function (date) { + return WEEKDAYS[date.tm_wday].substring(0, 3); + }, + "%A": function (date) { + return WEEKDAYS[date.tm_wday]; + }, + "%b": function (date) { + return MONTHS[date.tm_mon].substring(0, 3); + }, + "%B": function (date) { + return MONTHS[date.tm_mon]; + }, + "%C": function (date) { + var year = date.tm_year + 1900; + return leadingNulls((year / 100) | 0, 2); + }, + "%d": function (date) { + return leadingNulls(date.tm_mday, 2); + }, + "%e": function (date) { + return leadingSomething(date.tm_mday, 2, " "); + }, + "%g": function (date) { + return getWeekBasedYear(date).toString().substring(2); + }, + "%G": function (date) { + return getWeekBasedYear(date); + }, + "%H": function (date) { + return leadingNulls(date.tm_hour, 2); + }, + "%I": function (date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, + "%j": function (date) { + return leadingNulls( + date.tm_mday + + __arraySum( + __isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, + date.tm_mon - 1, + ), + 3, + ); + }, + "%m": function (date) { + return leadingNulls(date.tm_mon + 1, 2); + }, + "%M": function (date) { + return leadingNulls(date.tm_min, 2); + }, + "%n": function () { + return "\n"; + }, + "%p": function (date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return "AM"; + } + return "PM"; + }, + "%S": function (date) { + return leadingNulls(date.tm_sec, 2); + }, + "%t": function () { + return "\t"; + }, + "%u": function (date) { + return date.tm_wday || 7; + }, + "%U": function (date) { + var days = date.tm_yday + 7 - date.tm_wday; + return leadingNulls(Math.floor(days / 7), 2); + }, + "%V": function (date) { + var val = Math.floor((date.tm_yday + 7 - ((date.tm_wday + 6) % 7)) / 7); + if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) { + val++; + } + if (!val) { + val = 52; + var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7; + if (dec31 == 4 || (dec31 == 5 && __isLeapYear((date.tm_year % 400) - 1))) { + val++; + } + } else if (val == 53) { + var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7; + if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year))) val = 1; + } + return leadingNulls(val, 2); + }, + "%w": function (date) { + return date.tm_wday; + }, + "%W": function (date) { + var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7); + return leadingNulls(Math.floor(days / 7), 2); + }, + "%y": function (date) { + return (date.tm_year + 1900).toString().substring(2); + }, + "%Y": function (date) { + return date.tm_year + 1900; + }, + "%z": function (date) { + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + off = (off / 60) * 100 + (off % 60); + return (ahead ? "+" : "-") + String("0000" + off).slice(-4); + }, + "%Z": function (date) { + return date.tm_zone; + }, + "%%": function () { + return "%"; + }, + }; + pattern = pattern.replace(/%%/g, "\0\0"); + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date)); + } + } + pattern = pattern.replace(/\0\0/g, "%"); + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + writeArrayToMemory(bytes, s); + return bytes.length - 1; + } + function _strftime_l(s, maxsize, format, tm, loc) { + return _strftime(s, maxsize, format, tm); + } + function _wgpuBindGroupLayoutRelease(id) { + WebGPU.mgrBindGroupLayout.release(id); + } + function _wgpuBindGroupRelease(id) { + WebGPU.mgrBindGroup.release(id); + } + function _wgpuBufferGetMappedRange(bufferId, offset, size) { + var bufferWrapper = WebGPU.mgrBuffer.objects[bufferId]; + assert(typeof bufferWrapper != "undefined"); + if (size === 0) warnOnce("getMappedRange size=0 no longer means WGPU_WHOLE_MAP_SIZE"); + size = size >>> 0; + if (size === 4294967295) size = undefined; + if (bufferWrapper.mapMode !== 2) { + abort("GetMappedRange called, but buffer not mapped for writing"); + return 0; + } + var mapped; + try { + mapped = bufferWrapper.object["getMappedRange"](offset, size); + } catch (ex) { + err("wgpuBufferGetMappedRange(" + offset + ", " + size + ") failed: " + ex); + return 0; + } + var data = _malloc(mapped.byteLength); + HEAPU8.fill(0, data, mapped.byteLength); + bufferWrapper.onUnmap.push(function () { + new Uint8Array(mapped).set(HEAPU8.subarray(data, data + mapped.byteLength)); + _free(data); + }); + return data; + } + function _wgpuBufferReference(id) { + WebGPU.mgrBuffer.reference(id); + } + function _wgpuBufferRelease(id) { + WebGPU.mgrBuffer.release(id); + } + function _wgpuBufferUnmap(bufferId) { + var bufferWrapper = WebGPU.mgrBuffer.objects[bufferId]; + assert(typeof bufferWrapper != "undefined"); + if (!bufferWrapper.onUnmap) { + return; + } + for (var i = 0; i < bufferWrapper.onUnmap.length; ++i) { + bufferWrapper.onUnmap[i](); + } + bufferWrapper.onUnmap = undefined; + bufferWrapper.object["unmap"](); + } + function _wgpuCommandBufferRelease(id) { + WebGPU.mgrCommandBuffer.release(id); + } + function _wgpuCommandEncoderBeginComputePass(encoderId, descriptor) { + var desc; + function makeComputePassTimestampWrite(twPtr) { + return { + querySet: WebGPU.mgrQuerySet.get(HEAPU32[twPtr >> 2]), + queryIndex: HEAPU32[(twPtr + 4) >> 2], + location: WebGPU.ComputePassTimestampLocation[HEAPU32[(twPtr + 8) >> 2]], + }; + } + function makeComputePassTimestampWrites(count, twPtr) { + var timestampWrites = []; + for (var i = 0; i < count; ++i) { + timestampWrites.push(makeComputePassTimestampWrite(twPtr + 12 * i)); + } + return timestampWrites; + } + if (descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + desc = {}; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var timestampWriteCount = HEAPU32[(descriptor + 8) >> 2]; + if (timestampWriteCount) { + desc["timestampWrites"] = makeComputePassTimestampWrites( + timestampWriteCount, + HEAPU32[(descriptor + 12) >> 2], + ); + } + } + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + return WebGPU.mgrComputePassEncoder.create(commandEncoder["beginComputePass"](desc)); + } + function _wgpuCommandEncoderBeginRenderPass(encoderId, descriptor) { + assert(descriptor); + function makeColorAttachment(caPtr) { + var viewPtr = HEAPU32[caPtr >> 2]; + if (viewPtr === 0) { + return undefined; + } + var loadOpInt = HEAPU32[(caPtr + 8) >> 2]; + assert(loadOpInt !== 0); + var storeOpInt = HEAPU32[(caPtr + 12) >> 2]; + assert(storeOpInt !== 0); + var clearValue = WebGPU.makeColor(caPtr + 16); + return { + view: WebGPU.mgrTextureView.get(viewPtr), + resolveTarget: WebGPU.mgrTextureView.get(HEAPU32[(caPtr + 4) >> 2]), + clearValue: clearValue, + loadOp: WebGPU.LoadOp[loadOpInt], + storeOp: WebGPU.StoreOp[storeOpInt], + }; + } + function makeColorAttachments(count, caPtr) { + var attachments = []; + for (var i = 0; i < count; ++i) { + attachments.push(makeColorAttachment(caPtr + 48 * i)); + } + return attachments; + } + function makeDepthStencilAttachment(dsaPtr) { + if (dsaPtr === 0) return undefined; + return { + view: WebGPU.mgrTextureView.get(HEAPU32[dsaPtr >> 2]), + depthClearValue: HEAPF32[(dsaPtr + 12) >> 2], + depthLoadOp: WebGPU.LoadOp[HEAPU32[(dsaPtr + 4) >> 2]], + depthStoreOp: WebGPU.StoreOp[HEAPU32[(dsaPtr + 8) >> 2]], + depthReadOnly: HEAP8[(dsaPtr + 16) >> 0] !== 0, + stencilClearValue: HEAPU32[(dsaPtr + 28) >> 2], + stencilLoadOp: WebGPU.LoadOp[HEAPU32[(dsaPtr + 20) >> 2]], + stencilStoreOp: WebGPU.StoreOp[HEAPU32[(dsaPtr + 24) >> 2]], + stencilReadOnly: HEAP8[(dsaPtr + 32) >> 0] !== 0, + }; + } + function makeRenderPassTimestampWrite(twPtr) { + return { + querySet: WebGPU.mgrQuerySet.get(HEAPU32[twPtr >> 2]), + queryIndex: HEAPU32[(twPtr + 4) >> 2], + location: WebGPU.RenderPassTimestampLocation[HEAPU32[(twPtr + 8) >> 2]], + }; + } + function makeRenderPassTimestampWrites(count, twPtr) { + var timestampWrites = []; + for (var i = 0; i < count; ++i) { + timestampWrites.push(makeRenderPassTimestampWrite(twPtr + 12 * i)); + } + return timestampWrites; + } + function makeRenderPassDescriptor(descriptor) { + assert(descriptor); + var nextInChainPtr = HEAPU32[descriptor >> 2]; + var maxDrawCount = undefined; + if (nextInChainPtr !== 0) { + var sType = HEAPU32[(nextInChainPtr + 4) >> 2]; + assert(sType === 15); + assert(0 === HEAPU32[nextInChainPtr >> 2]); + var renderPassDescriptorMaxDrawCount = nextInChainPtr; + assert(renderPassDescriptorMaxDrawCount); + assert(HEAPU32[renderPassDescriptorMaxDrawCount >> 2] === 0); + maxDrawCount = + HEAPU32[(renderPassDescriptorMaxDrawCount + 4 + 8) >> 2] * 4294967296 + + HEAPU32[(renderPassDescriptorMaxDrawCount + 8) >> 2]; + } + var desc = { + label: undefined, + colorAttachments: makeColorAttachments( + HEAPU32[(descriptor + 8) >> 2], + HEAPU32[(descriptor + 12) >> 2], + ), + depthStencilAttachment: makeDepthStencilAttachment(HEAPU32[(descriptor + 16) >> 2]), + occlusionQuerySet: WebGPU.mgrQuerySet.get(HEAPU32[(descriptor + 20) >> 2]), + maxDrawCount: maxDrawCount, + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var timestampWriteCount = HEAPU32[(descriptor + 24) >> 2]; + if (timestampWriteCount) { + desc["timestampWrites"] = makeRenderPassTimestampWrites( + timestampWriteCount, + HEAPU32[(descriptor + 28) >> 2], + ); + } + return desc; + } + var desc = makeRenderPassDescriptor(descriptor); + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + return WebGPU.mgrRenderPassEncoder.create(commandEncoder["beginRenderPass"](desc)); + } + function _wgpuCommandEncoderCopyBufferToTexture(encoderId, srcPtr, dstPtr, copySizePtr) { + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + var copySize = WebGPU.makeExtent3D(copySizePtr); + commandEncoder["copyBufferToTexture"]( + WebGPU.makeImageCopyBuffer(srcPtr), + WebGPU.makeImageCopyTexture(dstPtr), + copySize, + ); + } + function _wgpuCommandEncoderCopyTextureToTexture(encoderId, srcPtr, dstPtr, copySizePtr) { + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + var copySize = WebGPU.makeExtent3D(copySizePtr); + commandEncoder["copyTextureToTexture"]( + WebGPU.makeImageCopyTexture(srcPtr), + WebGPU.makeImageCopyTexture(dstPtr), + copySize, + ); + } + function _wgpuCommandEncoderFinish(encoderId) { + var commandEncoder = WebGPU.mgrCommandEncoder.get(encoderId); + return WebGPU.mgrCommandBuffer.create(commandEncoder["finish"]()); + } + function _wgpuCommandEncoderRelease(id) { + WebGPU.mgrCommandEncoder.release(id); + } + function _wgpuComputePassEncoderDispatchWorkgroups(passId, x, y, z) { + var pass = WebGPU.mgrComputePassEncoder.get(passId); + if (pass["dispatchWorkgroups"]) { + pass["dispatchWorkgroups"](x, y, z); + } else { + pass["dispatch"](x, y, z); + } + } + function _wgpuComputePassEncoderEnd(passId) { + var pass = WebGPU.mgrComputePassEncoder.get(passId); + pass["end"](); + } + function _wgpuComputePassEncoderRelease(id) { + WebGPU.mgrComputePassEncoder.release(id); + } + function _wgpuComputePassEncoderSetBindGroup( + passId, + groupIndex, + groupId, + dynamicOffsetCount, + dynamicOffsetsPtr, + ) { + var pass = WebGPU.mgrComputePassEncoder.get(passId); + var group = WebGPU.mgrBindGroup.get(groupId); + if (dynamicOffsetCount == 0) { + pass["setBindGroup"](groupIndex, group); + } else { + var offsets = []; + for (var i = 0; i < dynamicOffsetCount; i++, dynamicOffsetsPtr += 4) { + offsets.push(HEAPU32[dynamicOffsetsPtr >> 2]); + } + pass["setBindGroup"](groupIndex, group, offsets); + } + } + function _wgpuComputePassEncoderSetPipeline(passId, pipelineId) { + var pass = WebGPU.mgrComputePassEncoder.get(passId); + var pipeline = WebGPU.mgrComputePipeline.get(pipelineId); + pass["setPipeline"](pipeline); + } + function _wgpuComputePipelineGetBindGroupLayout(pipelineId, groupIndex) { + var pipeline = WebGPU.mgrComputePipeline.get(pipelineId); + return WebGPU.mgrBindGroupLayout.create(pipeline["getBindGroupLayout"](groupIndex)); + } + function _wgpuComputePipelineRelease(id) { + WebGPU.mgrComputePipeline.release(id); + } + function _wgpuDeviceCreateBindGroup(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + function makeEntry(entryPtr) { + assert(entryPtr); + var bufferId = HEAPU32[(entryPtr + 8) >> 2]; + var samplerId = HEAPU32[(entryPtr + 32) >> 2]; + var textureViewId = HEAPU32[(entryPtr + 36) >> 2]; + assert((bufferId !== 0) + (samplerId !== 0) + (textureViewId !== 0) === 1); + var binding = HEAPU32[(entryPtr + 4) >> 2]; + if (bufferId) { + var size_low = HEAPU32[(entryPtr + 24) >> 2]; + var size_high = HEAPU32[(entryPtr + 28) >> 2]; + var size = + size_high === -1 && size_low === -1 + ? undefined + : (assert(size_high < 2097152), size_high * 4294967296 + size_low); + return { + binding: binding, + resource: { + buffer: WebGPU.mgrBuffer.get(bufferId), + offset: + HEAPU32[(entryPtr + 4 + 16) >> 2] * 4294967296 + HEAPU32[(entryPtr + 16) >> 2], + size: size, + }, + }; + } else if (samplerId) { + return { binding: binding, resource: WebGPU.mgrSampler.get(samplerId) }; + } else { + return { binding: binding, resource: WebGPU.mgrTextureView.get(textureViewId) }; + } + } + function makeEntries(count, entriesPtrs) { + var entries = []; + for (var i = 0; i < count; ++i) { + entries.push(makeEntry(entriesPtrs + 40 * i)); + } + return entries; + } + var desc = { + label: undefined, + layout: WebGPU.mgrBindGroupLayout.get(HEAPU32[(descriptor + 8) >> 2]), + entries: makeEntries(HEAPU32[(descriptor + 12) >> 2], HEAPU32[(descriptor + 16) >> 2]), + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrBindGroup.create(device["createBindGroup"](desc)); + } + function _wgpuDeviceCreateBuffer(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var mappedAtCreation = HEAP8[(descriptor + 24) >> 0] !== 0; + var desc = { + label: undefined, + usage: HEAPU32[(descriptor + 8) >> 2], + size: HEAPU32[(descriptor + 4 + 16) >> 2] * 4294967296 + HEAPU32[(descriptor + 16) >> 2], + mappedAtCreation: mappedAtCreation, + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + var bufferWrapper = {}; + var id = WebGPU.mgrBuffer.create(device["createBuffer"](desc), bufferWrapper); + if (mappedAtCreation) { + bufferWrapper.mapMode = 2; + bufferWrapper.onUnmap = []; + } + return id; + } + function _wgpuDeviceCreateCommandEncoder(deviceId, descriptor) { + var desc; + if (descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + desc = { label: undefined }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + } + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrCommandEncoder.create(device["createCommandEncoder"](desc)); + } + function _wgpuDeviceCreateComputePipeline(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var desc = { + label: undefined, + layout: WebGPU.mgrPipelineLayout.get(HEAPU32[(descriptor + 8) >> 2]), + compute: WebGPU.makeProgrammableStageDescriptor(descriptor + 12), + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrComputePipeline.create(device["createComputePipeline"](desc)); + } + function _wgpuDeviceCreateRenderPipeline(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + function makePrimitiveState(rsPtr) { + if (!rsPtr) return undefined; + assert(rsPtr); + assert(HEAPU32[rsPtr >> 2] === 0); + return { + topology: WebGPU.PrimitiveTopology[HEAPU32[(rsPtr + 4) >> 2]], + stripIndexFormat: WebGPU.IndexFormat[HEAPU32[(rsPtr + 8) >> 2]], + frontFace: WebGPU.FrontFace[HEAPU32[(rsPtr + 12) >> 2]], + cullMode: WebGPU.CullMode[HEAPU32[(rsPtr + 16) >> 2]], + }; + } + function makeBlendComponent(bdPtr) { + if (!bdPtr) return undefined; + return { + operation: WebGPU.BlendOperation[HEAPU32[bdPtr >> 2]], + srcFactor: WebGPU.BlendFactor[HEAPU32[(bdPtr + 4) >> 2]], + dstFactor: WebGPU.BlendFactor[HEAPU32[(bdPtr + 8) >> 2]], + }; + } + function makeBlendState(bsPtr) { + if (!bsPtr) return undefined; + assert(bsPtr); + assert(HEAPU32[bsPtr >> 2] === 0); + return { alpha: makeBlendComponent(bsPtr + 12), color: makeBlendComponent(bsPtr + 0) }; + } + function makeColorState(csPtr) { + assert(csPtr); + assert(HEAPU32[csPtr >> 2] === 0); + var formatInt = HEAPU32[(csPtr + 4) >> 2]; + return formatInt === 0 + ? undefined + : { + format: WebGPU.TextureFormat[formatInt], + blend: makeBlendState(HEAPU32[(csPtr + 8) >> 2]), + writeMask: HEAPU32[(csPtr + 12) >> 2], + }; + } + function makeColorStates(count, csArrayPtr) { + var states = []; + for (var i = 0; i < count; ++i) { + states.push(makeColorState(csArrayPtr + 16 * i)); + } + return states; + } + function makeStencilStateFace(ssfPtr) { + assert(ssfPtr); + return { + compare: WebGPU.CompareFunction[HEAPU32[ssfPtr >> 2]], + failOp: WebGPU.StencilOperation[HEAPU32[(ssfPtr + 4) >> 2]], + depthFailOp: WebGPU.StencilOperation[HEAPU32[(ssfPtr + 8) >> 2]], + passOp: WebGPU.StencilOperation[HEAPU32[(ssfPtr + 12) >> 2]], + }; + } + function makeDepthStencilState(dssPtr) { + if (!dssPtr) return undefined; + assert(dssPtr); + return { + format: WebGPU.TextureFormat[HEAPU32[(dssPtr + 4) >> 2]], + depthWriteEnabled: HEAP8[(dssPtr + 8) >> 0] !== 0, + depthCompare: WebGPU.CompareFunction[HEAPU32[(dssPtr + 12) >> 2]], + stencilFront: makeStencilStateFace(dssPtr + 16), + stencilBack: makeStencilStateFace(dssPtr + 32), + stencilReadMask: HEAPU32[(dssPtr + 48) >> 2], + stencilWriteMask: HEAPU32[(dssPtr + 52) >> 2], + depthBias: HEAPU32[(dssPtr + 56) >> 2], + depthBiasSlopeScale: HEAPF32[(dssPtr + 60) >> 2], + depthBiasClamp: HEAPF32[(dssPtr + 64) >> 2], + }; + } + function makeVertexAttribute(vaPtr) { + assert(vaPtr); + return { + format: WebGPU.VertexFormat[HEAPU32[vaPtr >> 2]], + offset: HEAPU32[(vaPtr + 4 + 8) >> 2] * 4294967296 + HEAPU32[(vaPtr + 8) >> 2], + shaderLocation: HEAPU32[(vaPtr + 16) >> 2], + }; + } + function makeVertexAttributes(count, vaArrayPtr) { + var vas = []; + for (var i = 0; i < count; ++i) { + vas.push(makeVertexAttribute(vaArrayPtr + i * 24)); + } + return vas; + } + function makeVertexBuffer(vbPtr) { + if (!vbPtr) return undefined; + var stepModeInt = HEAPU32[(vbPtr + 8) >> 2]; + return stepModeInt === 2 + ? null + : { + arrayStride: HEAPU32[(vbPtr + 4) >> 2] * 4294967296 + HEAPU32[vbPtr >> 2], + stepMode: WebGPU.VertexStepMode[stepModeInt], + attributes: makeVertexAttributes( + HEAPU32[(vbPtr + 12) >> 2], + HEAPU32[(vbPtr + 16) >> 2], + ), + }; + } + function makeVertexBuffers(count, vbArrayPtr) { + if (!count) return undefined; + var vbs = []; + for (var i = 0; i < count; ++i) { + vbs.push(makeVertexBuffer(vbArrayPtr + i * 24)); + } + return vbs; + } + function makeVertexState(viPtr) { + if (!viPtr) return undefined; + assert(viPtr); + assert(HEAPU32[viPtr >> 2] === 0); + return { + module: WebGPU.mgrShaderModule.get(HEAPU32[(viPtr + 4) >> 2]), + entryPoint: UTF8ToString(HEAPU32[(viPtr + 8) >> 2]), + constants: WebGPU.makePipelineConstants( + HEAPU32[(viPtr + 12) >> 2], + HEAPU32[(viPtr + 16) >> 2], + ), + buffers: makeVertexBuffers(HEAPU32[(viPtr + 20) >> 2], HEAPU32[(viPtr + 24) >> 2]), + }; + } + function makeMultisampleState(msPtr) { + if (!msPtr) return undefined; + assert(msPtr); + assert(HEAPU32[msPtr >> 2] === 0); + return { + count: HEAPU32[(msPtr + 4) >> 2], + mask: HEAPU32[(msPtr + 8) >> 2], + alphaToCoverageEnabled: HEAP8[(msPtr + 12) >> 0] !== 0, + }; + } + function makeFragmentState(fsPtr) { + if (!fsPtr) return undefined; + assert(fsPtr); + assert(HEAPU32[fsPtr >> 2] === 0); + return { + module: WebGPU.mgrShaderModule.get(HEAPU32[(fsPtr + 4) >> 2]), + entryPoint: UTF8ToString(HEAPU32[(fsPtr + 8) >> 2]), + constants: WebGPU.makePipelineConstants( + HEAPU32[(fsPtr + 12) >> 2], + HEAPU32[(fsPtr + 16) >> 2], + ), + targets: makeColorStates(HEAPU32[(fsPtr + 20) >> 2], HEAPU32[(fsPtr + 24) >> 2]), + }; + } + var desc = { + label: undefined, + layout: WebGPU.mgrPipelineLayout.get(HEAPU32[(descriptor + 8) >> 2]), + vertex: makeVertexState(descriptor + 12), + primitive: makePrimitiveState(descriptor + 40), + depthStencil: makeDepthStencilState(HEAPU32[(descriptor + 60) >> 2]), + multisample: makeMultisampleState(descriptor + 64), + fragment: makeFragmentState(HEAPU32[(descriptor + 80) >> 2]), + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrRenderPipeline.create(device["createRenderPipeline"](desc)); + } + function _wgpuDeviceCreateSampler(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var desc = { + label: undefined, + addressModeU: WebGPU.AddressMode[HEAPU32[(descriptor + 8) >> 2]], + addressModeV: WebGPU.AddressMode[HEAPU32[(descriptor + 12) >> 2]], + addressModeW: WebGPU.AddressMode[HEAPU32[(descriptor + 16) >> 2]], + magFilter: WebGPU.FilterMode[HEAPU32[(descriptor + 20) >> 2]], + minFilter: WebGPU.FilterMode[HEAPU32[(descriptor + 24) >> 2]], + mipmapFilter: WebGPU.FilterMode[HEAPU32[(descriptor + 28) >> 2]], + lodMinClamp: HEAPF32[(descriptor + 32) >> 2], + lodMaxClamp: HEAPF32[(descriptor + 36) >> 2], + compare: WebGPU.CompareFunction[HEAPU32[(descriptor + 40) >> 2]], + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrSampler.create(device["createSampler"](desc)); + } + function _wgpuDeviceCreateShaderModule(deviceId, descriptor) { + assert(descriptor); + var nextInChainPtr = HEAPU32[descriptor >> 2]; + assert(nextInChainPtr !== 0); + var sType = HEAPU32[(nextInChainPtr + 4) >> 2]; + var desc = { label: undefined, code: "" }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + switch (sType) { + case 5: { + var count = HEAPU32[(nextInChainPtr + 8) >> 2]; + var start = HEAPU32[(nextInChainPtr + 12) >> 2]; + desc["code"] = HEAPU32.subarray(start >> 2, (start >> 2) + count); + break; + } + case 6: { + var sourcePtr = HEAPU32[(nextInChainPtr + 8) >> 2]; + if (sourcePtr) { + desc["code"] = UTF8ToString(sourcePtr); + } + break; + } + default: + abort("unrecognized ShaderModule sType"); + } + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrShaderModule.create(device["createShaderModule"](desc)); + } + function _wgpuDeviceCreateTexture(deviceId, descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var desc = { + label: undefined, + size: WebGPU.makeExtent3D(descriptor + 16), + mipLevelCount: HEAPU32[(descriptor + 32) >> 2], + sampleCount: HEAPU32[(descriptor + 36) >> 2], + dimension: WebGPU.TextureDimension[HEAPU32[(descriptor + 12) >> 2]], + format: WebGPU.TextureFormat[HEAPU32[(descriptor + 28) >> 2]], + usage: HEAPU32[(descriptor + 8) >> 2], + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + var viewFormatCount = HEAPU32[(descriptor + 40) >> 2]; + if (viewFormatCount) { + var viewFormatsPtr = HEAPU32[(descriptor + 44) >> 2]; + desc["viewFormats"] = Array.from( + HEAP32.subarray(viewFormatsPtr >> 2, (viewFormatsPtr >> 2) + viewFormatCount), + function (format) { + return WebGPU.TextureFormat[format]; + }, + ); + } + var device = WebGPU.mgrDevice.get(deviceId); + return WebGPU.mgrTexture.create(device["createTexture"](desc)); + } + function _wgpuDeviceGetQueue(deviceId) { + var queueId = WebGPU.mgrDevice.objects[deviceId].queueId; + assert(queueId, "wgpuDeviceGetQueue: queue was missing or null"); + WebGPU.mgrQueue.reference(queueId); + return queueId; + } + function _wgpuDeviceReference(id) { + WebGPU.mgrDevice.reference(id); + } + function _wgpuDeviceRelease(id) { + WebGPU.mgrDevice.release(id); + } + function _wgpuPipelineLayoutRelease(id) { + WebGPU.mgrPipelineLayout.release(id); + } + function _wgpuQuerySetRelease(id) { + WebGPU.mgrQuerySet.release(id); + } + function _wgpuQueueRelease(id) { + WebGPU.mgrQueue.release(id); + } + function _wgpuQueueSubmit(queueId, commandCount, commands) { + assert(commands % 4 === 0); + var queue = WebGPU.mgrQueue.get(queueId); + var cmds = Array.from( + HEAP32.subarray(commands >> 2, (commands >> 2) + commandCount), + function (id) { + return WebGPU.mgrCommandBuffer.get(id); + }, + ); + queue["submit"](cmds); + } + function _wgpuQueueWriteBuffer( + queueId, + bufferId, + bufferOffset_low, + bufferOffset_high, + data, + size, + ) { + var queue = WebGPU.mgrQueue.get(queueId); + var buffer = WebGPU.mgrBuffer.get(bufferId); + var bufferOffset = + (assert(bufferOffset_high < 2097152), bufferOffset_high * 4294967296 + bufferOffset_low); + var subarray = HEAPU8.subarray(data, data + size); + queue["writeBuffer"](buffer, bufferOffset, subarray, 0, size); + } + function _wgpuRenderPassEncoderDraw( + passId, + vertexCount, + instanceCount, + firstVertex, + firstInstance, + ) { + var pass = WebGPU.mgrRenderPassEncoder.get(passId); + pass["draw"](vertexCount, instanceCount, firstVertex, firstInstance); + } + function _wgpuRenderPassEncoderEnd(passId) { + var pass = WebGPU.mgrRenderPassEncoder.get(passId); + pass["end"](); + } + function _wgpuRenderPassEncoderRelease(id) { + WebGPU.mgrRenderPassEncoder.release(id); + } + function _wgpuRenderPassEncoderSetBindGroup( + passId, + groupIndex, + groupId, + dynamicOffsetCount, + dynamicOffsetsPtr, + ) { + var pass = WebGPU.mgrRenderPassEncoder.get(passId); + var group = WebGPU.mgrBindGroup.get(groupId); + if (dynamicOffsetCount == 0) { + pass["setBindGroup"](groupIndex, group); + } else { + var offsets = []; + for (var i = 0; i < dynamicOffsetCount; i++, dynamicOffsetsPtr += 4) { + offsets.push(HEAPU32[dynamicOffsetsPtr >> 2]); + } + pass["setBindGroup"](groupIndex, group, offsets); + } + } + function _wgpuRenderPassEncoderSetPipeline(passId, pipelineId) { + var pass = WebGPU.mgrRenderPassEncoder.get(passId); + var pipeline = WebGPU.mgrRenderPipeline.get(pipelineId); + pass["setPipeline"](pipeline); + } + function _wgpuRenderPipelineGetBindGroupLayout(pipelineId, groupIndex) { + var pipeline = WebGPU.mgrRenderPipeline.get(pipelineId); + return WebGPU.mgrBindGroupLayout.create(pipeline["getBindGroupLayout"](groupIndex)); + } + function _wgpuRenderPipelineRelease(id) { + WebGPU.mgrRenderPipeline.release(id); + } + function _wgpuSamplerReference(id) { + WebGPU.mgrSampler.reference(id); + } + function _wgpuSamplerRelease(id) { + WebGPU.mgrSampler.release(id); + } + function _wgpuShaderModuleReference(id) { + WebGPU.mgrShaderModule.reference(id); + } + function _wgpuShaderModuleRelease(id) { + WebGPU.mgrShaderModule.release(id); + } + function _wgpuTextureCreateView(textureId, descriptor) { + var desc; + if (descriptor) { + assert(descriptor); + assert(HEAPU32[descriptor >> 2] === 0); + var mipLevelCount = HEAPU32[(descriptor + 20) >> 2]; + var arrayLayerCount = HEAPU32[(descriptor + 28) >> 2]; + desc = { + format: WebGPU.TextureFormat[HEAPU32[(descriptor + 8) >> 2]], + dimension: WebGPU.TextureViewDimension[HEAPU32[(descriptor + 12) >> 2]], + baseMipLevel: HEAPU32[(descriptor + 16) >> 2], + mipLevelCount: mipLevelCount === 4294967295 ? undefined : mipLevelCount, + baseArrayLayer: HEAPU32[(descriptor + 24) >> 2], + arrayLayerCount: arrayLayerCount === 4294967295 ? undefined : arrayLayerCount, + aspect: WebGPU.TextureAspect[HEAPU32[(descriptor + 32) >> 2]], + }; + var labelPtr = HEAPU32[(descriptor + 4) >> 2]; + if (labelPtr) desc["label"] = UTF8ToString(labelPtr); + } + var texture = WebGPU.mgrTexture.get(textureId); + return WebGPU.mgrTextureView.create(texture["createView"](desc)); + } + function _wgpuTextureDestroy(textureId) { + WebGPU.mgrTexture.get(textureId)["destroy"](); + } + function _wgpuTextureReference(id) { + WebGPU.mgrTexture.reference(id); + } + function _wgpuTextureRelease(id) { + WebGPU.mgrTexture.release(id); + } + function _wgpuTextureViewReference(id) { + WebGPU.mgrTextureView.reference(id); + } + function _wgpuTextureViewRelease(id) { + WebGPU.mgrTextureView.release(id); + } + Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas) { + Browser.requestFullscreen(lockPointer, resizeCanvas); + }; + Module["requestFullScreen"] = function Module_requestFullScreen() { + Browser.requestFullScreen(); + }; + Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { + Browser.requestAnimationFrame(func); + }; + Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { + Browser.setCanvasSize(width, height, noUpdates); + }; + Module["pauseMainLoop"] = function Module_pauseMainLoop() { + Browser.mainLoop.pause(); + }; + Module["resumeMainLoop"] = function Module_resumeMainLoop() { + Browser.mainLoop.resume(); + }; + Module["getUserMedia"] = function Module_getUserMedia() { + Browser.getUserMedia(); + }; + Module["createContext"] = function Module_createContext( + canvas, + useWebGL, + setInModule, + webGLContextAttributes, + ) { + return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes); + }; + var preloadedImages = {}; + var preloadedAudios = {}; + var FSNode = function (parent, name, mode, rdev) { + if (!parent) { + parent = this; + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + }; + var readMode = 292 | 73; + var writeMode = 146; + Object.defineProperties(FSNode.prototype, { + read: { + get: function () { + return (this.mode & readMode) === readMode; + }, + set: function (val) { + val ? (this.mode |= readMode) : (this.mode &= ~readMode); + }, + }, + write: { + get: function () { + return (this.mode & writeMode) === writeMode; + }, + set: function (val) { + val ? (this.mode |= writeMode) : (this.mode &= ~writeMode); + }, + }, + isFolder: { + get: function () { + return FS.isDir(this.mode); + }, + }, + isDevice: { + get: function () { + return FS.isChrdev(this.mode); + }, + }, + }); + FS.FSNode = FSNode; + FS.staticInit(); + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_unlink"] = FS.unlink; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createDevice"] = FS.createDevice; + ERRNO_CODES = { + EPERM: 63, + ENOENT: 44, + ESRCH: 71, + EINTR: 27, + EIO: 29, + ENXIO: 60, + E2BIG: 1, + ENOEXEC: 45, + EBADF: 8, + ECHILD: 12, + EAGAIN: 6, + EWOULDBLOCK: 6, + ENOMEM: 48, + EACCES: 2, + EFAULT: 21, + ENOTBLK: 105, + EBUSY: 10, + EEXIST: 20, + EXDEV: 75, + ENODEV: 43, + ENOTDIR: 54, + EISDIR: 31, + EINVAL: 28, + ENFILE: 41, + EMFILE: 33, + ENOTTY: 59, + ETXTBSY: 74, + EFBIG: 22, + ENOSPC: 51, + ESPIPE: 70, + EROFS: 69, + EMLINK: 34, + EPIPE: 64, + EDOM: 18, + ERANGE: 68, + ENOMSG: 49, + EIDRM: 24, + ECHRNG: 106, + EL2NSYNC: 156, + EL3HLT: 107, + EL3RST: 108, + ELNRNG: 109, + EUNATCH: 110, + ENOCSI: 111, + EL2HLT: 112, + EDEADLK: 16, + ENOLCK: 46, + EBADE: 113, + EBADR: 114, + EXFULL: 115, + ENOANO: 104, + EBADRQC: 103, + EBADSLT: 102, + EDEADLOCK: 16, + EBFONT: 101, + ENOSTR: 100, + ENODATA: 116, + ETIME: 117, + ENOSR: 118, + ENONET: 119, + ENOPKG: 120, + EREMOTE: 121, + ENOLINK: 47, + EADV: 122, + ESRMNT: 123, + ECOMM: 124, + EPROTO: 65, + EMULTIHOP: 36, + EDOTDOT: 125, + EBADMSG: 9, + ENOTUNIQ: 126, + EBADFD: 127, + EREMCHG: 128, + ELIBACC: 129, + ELIBBAD: 130, + ELIBSCN: 131, + ELIBMAX: 132, + ELIBEXEC: 133, + ENOSYS: 52, + ENOTEMPTY: 55, + ENAMETOOLONG: 37, + ELOOP: 32, + EOPNOTSUPP: 138, + EPFNOSUPPORT: 139, + ECONNRESET: 15, + ENOBUFS: 42, + EAFNOSUPPORT: 5, + EPROTOTYPE: 67, + ENOTSOCK: 57, + ENOPROTOOPT: 50, + ESHUTDOWN: 140, + ECONNREFUSED: 14, + EADDRINUSE: 3, + ECONNABORTED: 13, + ENETUNREACH: 40, + ENETDOWN: 38, + ETIMEDOUT: 73, + EHOSTDOWN: 142, + EHOSTUNREACH: 23, + EINPROGRESS: 26, + EALREADY: 7, + EDESTADDRREQ: 17, + EMSGSIZE: 35, + EPROTONOSUPPORT: 66, + ESOCKTNOSUPPORT: 137, + EADDRNOTAVAIL: 4, + ENETRESET: 39, + EISCONN: 30, + ENOTCONN: 53, + ETOOMANYREFS: 141, + EUSERS: 136, + EDQUOT: 19, + ESTALE: 72, + ENOTSUP: 138, + ENOMEDIUM: 148, + EILSEQ: 25, + EOVERFLOW: 61, + ECANCELED: 11, + ENOTRECOVERABLE: 56, + EOWNERDEAD: 62, + ESTRPIPE: 135, + }; + BindingError = Module["BindingError"] = extendError(Error, "BindingError"); + init_emval(); + PureVirtualError = Module["PureVirtualError"] = extendError(Error, "PureVirtualError"); + embind_init_charCodes(); + init_embind(); + InternalError = Module["InternalError"] = extendError(Error, "InternalError"); + init_ClassHandle(); + init_RegisteredPointer(); + UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError"); + var GLctx; + WebGPU.initManagers(); + for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i)); + var miniTempWebGLFloatBuffersStorage = new Float32Array(288); + for (var i = 0; i < 288; ++i) { + miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i + 1); + } + var __miniTempWebGLIntBuffersStorage = new Int32Array(288); + for (var i = 0; i < 288; ++i) { + __miniTempWebGLIntBuffers[i] = __miniTempWebGLIntBuffersStorage.subarray(0, i + 1); + } + var decodeBase64 = + typeof atob == "function" + ? atob + : function (input) { + var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + var output = ""; + var chr1, chr2, chr3; + var enc1, enc2, enc3, enc4; + var i = 0; + input = input.replace(/[^A-Za-z0-9+/=]/g, ""); + do { + enc1 = keyStr.indexOf(input.charAt(i++)); + enc2 = keyStr.indexOf(input.charAt(i++)); + enc3 = keyStr.indexOf(input.charAt(i++)); + enc4 = keyStr.indexOf(input.charAt(i++)); + chr1 = (enc1 << 2) | (enc2 >> 4); + chr2 = ((enc2 & 15) << 4) | (enc3 >> 2); + chr3 = ((enc3 & 3) << 6) | enc4; + output = output + String.fromCharCode(chr1); + if (enc3 !== 64) { + output = output + String.fromCharCode(chr2); + } + if (enc4 !== 64) { + output = output + String.fromCharCode(chr3); + } + } while (i < input.length); + return output; + }; + function intArrayFromBase64(s) { + if (typeof ENVIRONMENT_IS_NODE == "boolean" && ENVIRONMENT_IS_NODE) { + var buf = Buffer.from(s, "base64"); + return new Uint8Array(buf["buffer"], buf["byteOffset"], buf["byteLength"]); + } + try { + var decoded = decodeBase64(s); + var bytes = new Uint8Array(decoded.length); + for (var i = 0; i < decoded.length; ++i) { + bytes[i] = decoded.charCodeAt(i); + } + return bytes; + } catch (_) { + throw new Error("Converting base64 string to bytes failed."); + } + } + function checkIncomingModuleAPI() { + ignoredModuleProp("fetchSettings"); + } + var asmLibraryArg = { + HaveOffsetConverter: HaveOffsetConverter, + __assert_fail: ___assert_fail, + __cxa_allocate_exception: ___cxa_allocate_exception, + __cxa_throw: ___cxa_throw, + __syscall_dup: ___syscall_dup, + __syscall_fcntl64: ___syscall_fcntl64, + __syscall_fstat64: ___syscall_fstat64, + __syscall_ioctl: ___syscall_ioctl, + __syscall_lstat64: ___syscall_lstat64, + __syscall_newfstatat: ___syscall_newfstatat, + __syscall_openat: ___syscall_openat, + __syscall_stat64: ___syscall_stat64, + _dlinit: __dlinit, + _dlopen_js: __dlopen_js, + _dlsym_js: __dlsym_js, + _embind_create_inheriting_constructor: __embind_create_inheriting_constructor, + _embind_finalize_value_object: __embind_finalize_value_object, + _embind_register_bigint: __embind_register_bigint, + _embind_register_bool: __embind_register_bool, + _embind_register_class: __embind_register_class, + _embind_register_class_class_function: __embind_register_class_class_function, + _embind_register_class_constructor: __embind_register_class_constructor, + _embind_register_class_function: __embind_register_class_function, + _embind_register_class_property: __embind_register_class_property, + _embind_register_emval: __embind_register_emval, + _embind_register_float: __embind_register_float, + _embind_register_function: __embind_register_function, + _embind_register_integer: __embind_register_integer, + _embind_register_memory_view: __embind_register_memory_view, + _embind_register_std_string: __embind_register_std_string, + _embind_register_std_wstring: __embind_register_std_wstring, + _embind_register_value_object: __embind_register_value_object, + _embind_register_value_object_field: __embind_register_value_object_field, + _embind_register_void: __embind_register_void, + _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic, + _emval_as: __emval_as, + _emval_call_void_method: __emval_call_void_method, + _emval_decref: __emval_decref, + _emval_get_global: __emval_get_global, + _emval_get_method_caller: __emval_get_method_caller, + _emval_get_property: __emval_get_property, + _emval_incref: __emval_incref, + _emval_instanceof: __emval_instanceof, + _emval_new_cstring: __emval_new_cstring, + _emval_run_destructors: __emval_run_destructors, + _emval_set_property: __emval_set_property, + _emval_take_value: __emval_take_value, + _emval_typeof: __emval_typeof, + _gmtime_js: __gmtime_js, + _localtime_js: __localtime_js, + _mktime_js: __mktime_js, + _mmap_js: __mmap_js, + _munmap_js: __munmap_js, + _tzset_js: __tzset_js, + abort: _abort, + emscripten_asm_const_int: _emscripten_asm_const_int, + emscripten_date_now: _emscripten_date_now, + emscripten_get_heap_max: _emscripten_get_heap_max, + emscripten_get_now: _emscripten_get_now, + emscripten_memcpy_big: _emscripten_memcpy_big, + emscripten_pc_get_function: _emscripten_pc_get_function, + emscripten_resize_heap: _emscripten_resize_heap, + emscripten_stack_snapshot: _emscripten_stack_snapshot, + emscripten_stack_unwind_buffer: _emscripten_stack_unwind_buffer, + emscripten_webgl_create_context: _emscripten_webgl_create_context, + emscripten_webgl_destroy_context: _emscripten_webgl_destroy_context, + emscripten_webgl_get_context_attributes: _emscripten_webgl_get_context_attributes, + emscripten_webgl_get_current_context: _emscripten_webgl_get_current_context, + emscripten_webgl_init_context_attributes: _emscripten_webgl_init_context_attributes, + emscripten_webgl_make_context_current: _emscripten_webgl_make_context_current, + emscripten_webgpu_export_bind_group_layout: _emscripten_webgpu_export_bind_group_layout, + emscripten_webgpu_export_device: _emscripten_webgpu_export_device, + emscripten_webgpu_export_sampler: _emscripten_webgpu_export_sampler, + emscripten_webgpu_export_texture: _emscripten_webgpu_export_texture, + emscripten_webgpu_get_device: _emscripten_webgpu_get_device, + emscripten_webgpu_import_bind_group: _emscripten_webgpu_import_bind_group, + emscripten_webgpu_import_texture: _emscripten_webgpu_import_texture, + emscripten_webgpu_release_js_handle: _emscripten_webgpu_release_js_handle, + environ_get: _environ_get, + environ_sizes_get: _environ_sizes_get, + exit: _exit, + fd_close: _fd_close, + fd_read: _fd_read, + fd_seek: _fd_seek, + fd_write: _fd_write, + getentropy: _getentropy, + glActiveTexture: _glActiveTexture, + glAttachShader: _glAttachShader, + glBindAttribLocation: _glBindAttribLocation, + glBindBuffer: _glBindBuffer, + glBindBufferBase: _glBindBufferBase, + glBindFramebuffer: _glBindFramebuffer, + glBindTexture: _glBindTexture, + glBindVertexArray: _glBindVertexArray, + glBufferData: _glBufferData, + glClientWaitSync: _glClientWaitSync, + glCompileShader: _glCompileShader, + glCreateProgram: _glCreateProgram, + glCreateShader: _glCreateShader, + glDeleteBuffers: _glDeleteBuffers, + glDeleteFramebuffers: _glDeleteFramebuffers, + glDeleteProgram: _glDeleteProgram, + glDeleteShader: _glDeleteShader, + glDeleteSync: _glDeleteSync, + glDeleteTextures: _glDeleteTextures, + glDeleteVertexArrays: _glDeleteVertexArrays, + glDisable: _glDisable, + glDisableVertexAttribArray: _glDisableVertexAttribArray, + glDrawArrays: _glDrawArrays, + glDrawBuffers: _glDrawBuffers, + glEnableVertexAttribArray: _glEnableVertexAttribArray, + glFenceSync: _glFenceSync, + glFinish: _glFinish, + glFlush: _glFlush, + glFramebufferTexture2D: _glFramebufferTexture2D, + glFramebufferTextureLayer: _glFramebufferTextureLayer, + glGenBuffers: _glGenBuffers, + glGenFramebuffers: _glGenFramebuffers, + glGenTextures: _glGenTextures, + glGenVertexArrays: _glGenVertexArrays, + glGetAttribLocation: _glGetAttribLocation, + glGetError: _glGetError, + glGetIntegerv: _glGetIntegerv, + glGetProgramiv: _glGetProgramiv, + glGetShaderInfoLog: _glGetShaderInfoLog, + glGetShaderiv: _glGetShaderiv, + glGetString: _glGetString, + glGetUniformBlockIndex: _glGetUniformBlockIndex, + glGetUniformLocation: _glGetUniformLocation, + glLinkProgram: _glLinkProgram, + glPixelStorei: _glPixelStorei, + glReadPixels: _glReadPixels, + glShaderSource: _glShaderSource, + glTexImage2D: _glTexImage2D, + glTexParameterfv: _glTexParameterfv, + glTexParameteri: _glTexParameteri, + glTexStorage2D: _glTexStorage2D, + glTexStorage3D: _glTexStorage3D, + glTexSubImage2D: _glTexSubImage2D, + glTexSubImage3D: _glTexSubImage3D, + glUniform1f: _glUniform1f, + glUniform1i: _glUniform1i, + glUniform2fv: _glUniform2fv, + glUniform4fv: _glUniform4fv, + glUniform4iv: _glUniform4iv, + glUniformBlockBinding: _glUniformBlockBinding, + glUniformMatrix4fv: _glUniformMatrix4fv, + glUseProgram: _glUseProgram, + glVertexAttribPointer: _glVertexAttribPointer, + glViewport: _glViewport, + mediapipe_create_utility_canvas2d: mediapipe_create_utility_canvas2d, + mediapipe_find_canvas_event_target: _mediapipe_find_canvas_event_target, + mediapipe_import_external_texture: mediapipe_import_external_texture, + mediapipe_webgl_tex_image_drawable: _mediapipe_webgl_tex_image_drawable, + proc_exit: _proc_exit, + strftime: _strftime, + strftime_l: _strftime_l, + wgpuBindGroupLayoutRelease: _wgpuBindGroupLayoutRelease, + wgpuBindGroupRelease: _wgpuBindGroupRelease, + wgpuBufferGetMappedRange: _wgpuBufferGetMappedRange, + wgpuBufferReference: _wgpuBufferReference, + wgpuBufferRelease: _wgpuBufferRelease, + wgpuBufferUnmap: _wgpuBufferUnmap, + wgpuCommandBufferRelease: _wgpuCommandBufferRelease, + wgpuCommandEncoderBeginComputePass: _wgpuCommandEncoderBeginComputePass, + wgpuCommandEncoderBeginRenderPass: _wgpuCommandEncoderBeginRenderPass, + wgpuCommandEncoderCopyBufferToTexture: _wgpuCommandEncoderCopyBufferToTexture, + wgpuCommandEncoderCopyTextureToTexture: _wgpuCommandEncoderCopyTextureToTexture, + wgpuCommandEncoderFinish: _wgpuCommandEncoderFinish, + wgpuCommandEncoderRelease: _wgpuCommandEncoderRelease, + wgpuComputePassEncoderDispatchWorkgroups: _wgpuComputePassEncoderDispatchWorkgroups, + wgpuComputePassEncoderEnd: _wgpuComputePassEncoderEnd, + wgpuComputePassEncoderRelease: _wgpuComputePassEncoderRelease, + wgpuComputePassEncoderSetBindGroup: _wgpuComputePassEncoderSetBindGroup, + wgpuComputePassEncoderSetPipeline: _wgpuComputePassEncoderSetPipeline, + wgpuComputePipelineGetBindGroupLayout: _wgpuComputePipelineGetBindGroupLayout, + wgpuComputePipelineRelease: _wgpuComputePipelineRelease, + wgpuDeviceCreateBindGroup: _wgpuDeviceCreateBindGroup, + wgpuDeviceCreateBuffer: _wgpuDeviceCreateBuffer, + wgpuDeviceCreateCommandEncoder: _wgpuDeviceCreateCommandEncoder, + wgpuDeviceCreateComputePipeline: _wgpuDeviceCreateComputePipeline, + wgpuDeviceCreateRenderPipeline: _wgpuDeviceCreateRenderPipeline, + wgpuDeviceCreateSampler: _wgpuDeviceCreateSampler, + wgpuDeviceCreateShaderModule: _wgpuDeviceCreateShaderModule, + wgpuDeviceCreateTexture: _wgpuDeviceCreateTexture, + wgpuDeviceGetQueue: _wgpuDeviceGetQueue, + wgpuDeviceReference: _wgpuDeviceReference, + wgpuDeviceRelease: _wgpuDeviceRelease, + wgpuPipelineLayoutRelease: _wgpuPipelineLayoutRelease, + wgpuQuerySetRelease: _wgpuQuerySetRelease, + wgpuQueueRelease: _wgpuQueueRelease, + wgpuQueueSubmit: _wgpuQueueSubmit, + wgpuQueueWriteBuffer: _wgpuQueueWriteBuffer, + wgpuRenderPassEncoderDraw: _wgpuRenderPassEncoderDraw, + wgpuRenderPassEncoderEnd: _wgpuRenderPassEncoderEnd, + wgpuRenderPassEncoderRelease: _wgpuRenderPassEncoderRelease, + wgpuRenderPassEncoderSetBindGroup: _wgpuRenderPassEncoderSetBindGroup, + wgpuRenderPassEncoderSetPipeline: _wgpuRenderPassEncoderSetPipeline, + wgpuRenderPipelineGetBindGroupLayout: _wgpuRenderPipelineGetBindGroupLayout, + wgpuRenderPipelineRelease: _wgpuRenderPipelineRelease, + wgpuSamplerReference: _wgpuSamplerReference, + wgpuSamplerRelease: _wgpuSamplerRelease, + wgpuShaderModuleReference: _wgpuShaderModuleReference, + wgpuShaderModuleRelease: _wgpuShaderModuleRelease, + wgpuTextureCreateView: _wgpuTextureCreateView, + wgpuTextureDestroy: _wgpuTextureDestroy, + wgpuTextureReference: _wgpuTextureReference, + wgpuTextureRelease: _wgpuTextureRelease, + wgpuTextureViewReference: _wgpuTextureViewReference, + wgpuTextureViewRelease: _wgpuTextureViewRelease, + }; + var asm = createWasm(); + var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = + createExportWrapper("__wasm_call_ctors")); + var _malloc = (Module["_malloc"] = createExportWrapper("malloc")); + var _free = (Module["_free"] = createExportWrapper("free")); + var ___errno_location = (Module["___errno_location"] = createExportWrapper("__errno_location")); + var _fflush = (Module["_fflush"] = createExportWrapper("fflush")); + var ___getTypeName = (Module["___getTypeName"] = createExportWrapper("__getTypeName")); + var __embind_initialize_bindings = (Module["__embind_initialize_bindings"] = + createExportWrapper("_embind_initialize_bindings")); + var ___dl_seterr = (Module["___dl_seterr"] = createExportWrapper("__dl_seterr")); + var _emscripten_builtin_memalign = (Module["_emscripten_builtin_memalign"] = + createExportWrapper("emscripten_builtin_memalign")); + var _emscripten_stack_init = (Module["_emscripten_stack_init"] = function () { + return (_emscripten_stack_init = Module["_emscripten_stack_init"] = + Module["asm"]["emscripten_stack_init"]).apply(null, arguments); + }); + var _emscripten_stack_get_free = (Module["_emscripten_stack_get_free"] = function () { + return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = + Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments); + }); + var _emscripten_stack_get_base = (Module["_emscripten_stack_get_base"] = function () { + return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = + Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments); + }); + var _emscripten_stack_get_end = (Module["_emscripten_stack_get_end"] = function () { + return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = + Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments); + }); + var stackSave = (Module["stackSave"] = createExportWrapper("stackSave")); + var stackRestore = (Module["stackRestore"] = createExportWrapper("stackRestore")); + var stackAlloc = (Module["stackAlloc"] = createExportWrapper("stackAlloc")); + var _emscripten_stack_get_current = (Module["_emscripten_stack_get_current"] = function () { + return (_emscripten_stack_get_current = Module["_emscripten_stack_get_current"] = + Module["asm"]["emscripten_stack_get_current"]).apply(null, arguments); + }); + var ___cxa_is_pointer_type = (Module["___cxa_is_pointer_type"] = + createExportWrapper("__cxa_is_pointer_type")); + var dynCall_jii = (Module["dynCall_jii"] = createExportWrapper("dynCall_jii")); + var dynCall_iiiijij = (Module["dynCall_iiiijij"] = createExportWrapper("dynCall_iiiijij")); + var dynCall_ji = (Module["dynCall_ji"] = createExportWrapper("dynCall_ji")); + var dynCall_viji = (Module["dynCall_viji"] = createExportWrapper("dynCall_viji")); + var dynCall_jjj = (Module["dynCall_jjj"] = createExportWrapper("dynCall_jjj")); + var dynCall_jiii = (Module["dynCall_jiii"] = createExportWrapper("dynCall_jiii")); + var dynCall_iiiijj = (Module["dynCall_iiiijj"] = createExportWrapper("dynCall_iiiijj")); + var dynCall_viijj = (Module["dynCall_viijj"] = createExportWrapper("dynCall_viijj")); + var dynCall_viiijjj = (Module["dynCall_viiijjj"] = createExportWrapper("dynCall_viiijjj")); + var dynCall_vij = (Module["dynCall_vij"] = createExportWrapper("dynCall_vij")); + var dynCall_viijii = (Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii")); + var dynCall_vijjj = (Module["dynCall_vijjj"] = createExportWrapper("dynCall_vijjj")); + var dynCall_vj = (Module["dynCall_vj"] = createExportWrapper("dynCall_vj")); + var dynCall_viij = (Module["dynCall_viij"] = createExportWrapper("dynCall_viij")); + var dynCall_viiiiij = (Module["dynCall_viiiiij"] = createExportWrapper("dynCall_viiiiij")); + var dynCall_iijjiiii = (Module["dynCall_iijjiiii"] = createExportWrapper("dynCall_iijjiiii")); + var dynCall_jiji = (Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji")); + var dynCall_iiiiij = (Module["dynCall_iiiiij"] = createExportWrapper("dynCall_iiiiij")); + var dynCall_iiiiijj = (Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj")); + var dynCall_iiiiiijj = (Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj")); + var ___start_em_js = (Module["___start_em_js"] = 515059); + var ___stop_em_js = (Module["___stop_em_js"] = 515579); + Module["addRunDependency"] = addRunDependency; + Module["removeRunDependency"] = removeRunDependency; + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createDevice"] = FS.createDevice; + Module["FS_unlink"] = FS.unlink; + Module["GL"] = GL; + var unexportedRuntimeSymbols = [ + "run", + "UTF8ArrayToString", + "UTF8ToString", + "stringToUTF8Array", + "stringToUTF8", + "lengthBytesUTF8", + "addOnPreRun", + "addOnInit", + "addOnPreMain", + "addOnExit", + "addOnPostRun", + "FS_createFolder", + "FS_createLink", + "getLEB", + "getFunctionTables", + "alignFunctionTables", + "registerFunctions", + "prettyPrint", + "getCompilerSetting", + "out", + "err", + "callMain", + "abort", + "keepRuntimeAlive", + "wasmMemory", + "stackAlloc", + "stackSave", + "stackRestore", + "getTempRet0", + "setTempRet0", + "writeStackCookie", + "checkStackCookie", + "ptrToString", + "zeroMemory", + "stringToNewUTF8", + "exitJS", + "getHeapMax", + "emscripten_realloc_buffer", + "ENV", + "ERRNO_CODES", + "ERRNO_MESSAGES", + "setErrNo", + "inetPton4", + "inetNtop4", + "inetPton6", + "inetNtop6", + "readSockaddr", + "writeSockaddr", + "DNS", + "getHostByName", + "Protocols", + "Sockets", + "getRandomDevice", + "warnOnce", + "traverseStack", + "UNWIND_CACHE", + "convertPCtoSourceLocation", + "readEmAsmArgsArray", + "readEmAsmArgs", + "runEmAsmFunction", + "runMainThreadEmAsm", + "jstoi_q", + "jstoi_s", + "getExecutableName", + "listenOnce", + "autoResumeAudioContext", + "dynCallLegacy", + "getDynCaller", + "dynCall", + "handleException", + "runtimeKeepalivePush", + "runtimeKeepalivePop", + "callUserCallback", + "maybeExit", + "safeSetTimeout", + "asmjsMangle", + "asyncLoad", + "alignMemory", + "mmapAlloc", + "writeI53ToI64", + "writeI53ToI64Clamped", + "writeI53ToI64Signaling", + "writeI53ToU64Clamped", + "writeI53ToU64Signaling", + "readI53FromI64", + "readI53FromU64", + "convertI32PairToI53", + "convertI32PairToI53Checked", + "convertU32PairToI53", + "getCFunc", + "ccall", + "cwrap", + "uleb128Encode", + "sigToWasmTypes", + "generateFuncType", + "convertJsFunctionToWasm", + "freeTableIndexes", + "functionsInTableMap", + "getEmptyTableSlot", + "updateTableMap", + "addFunction", + "removeFunction", + "reallyNegative", + "unSign", + "strLen", + "reSign", + "formatString", + "setValue", + "getValue", + "PATH", + "PATH_FS", + "intArrayFromString", + "intArrayToString", + "AsciiToString", + "stringToAscii", + "UTF16Decoder", + "UTF16ToString", + "stringToUTF16", + "lengthBytesUTF16", + "UTF32ToString", + "stringToUTF32", + "lengthBytesUTF32", + "allocateUTF8", + "allocateUTF8OnStack", + "writeStringToMemory", + "writeArrayToMemory", + "writeAsciiToMemory", + "SYSCALLS", + "getSocketFromFD", + "getSocketAddress", + "JSEvents", + "registerKeyEventCallback", + "specialHTMLTargets", + "findEventTarget", + "findCanvasEventTarget", + "getBoundingClientRect", + "fillMouseEventData", + "registerMouseEventCallback", + "registerWheelEventCallback", + "registerUiEventCallback", + "registerFocusEventCallback", + "fillDeviceOrientationEventData", + "registerDeviceOrientationEventCallback", + "fillDeviceMotionEventData", + "registerDeviceMotionEventCallback", + "screenOrientation", + "fillOrientationChangeEventData", + "registerOrientationChangeEventCallback", + "fillFullscreenChangeEventData", + "registerFullscreenChangeEventCallback", + "JSEvents_requestFullscreen", + "JSEvents_resizeCanvasForFullscreen", + "registerRestoreOldStyle", + "hideEverythingExceptGivenElement", + "restoreHiddenElements", + "setLetterbox", + "currentFullscreenStrategy", + "restoreOldWindowedStyle", + "softFullscreenResizeWebGLRenderTarget", + "doRequestFullscreen", + "fillPointerlockChangeEventData", + "registerPointerlockChangeEventCallback", + "registerPointerlockErrorEventCallback", + "requestPointerLock", + "fillVisibilityChangeEventData", + "registerVisibilityChangeEventCallback", + "registerTouchEventCallback", + "fillGamepadEventData", + "registerGamepadEventCallback", + "registerBeforeUnloadEventCallback", + "fillBatteryEventData", + "battery", + "registerBatteryEventCallback", + "setCanvasElementSize", + "getCanvasElementSize", + "demangle", + "demangleAll", + "jsStackTrace", + "stackTrace", + "ExitStatus", + "getEnvStrings", + "checkWasiClock", + "doReadv", + "doWritev", + "dlopenMissingError", + "createDyncallWrapper", + "setImmediateWrapped", + "clearImmediateWrapped", + "polyfillSetImmediate", + "uncaughtExceptionCount", + "exceptionLast", + "exceptionCaught", + "ExceptionInfo", + "exception_addRef", + "exception_decRef", + "Browser", + "setMainLoop", + "wget", + "FS", + "MEMFS", + "TTY", + "PIPEFS", + "SOCKFS", + "_setNetworkCallback", + "tempFixedLengthArray", + "miniTempWebGLFloatBuffers", + "heapObjectForWebGLType", + "heapAccessShiftForWebGLHeap", + "emscriptenWebGLGet", + "computeUnpackAlignedImageSize", + "emscriptenWebGLGetTexPixelData", + "emscriptenWebGLGetUniform", + "webglGetUniformLocation", + "webglPrepareUniformLocationsBeforeFirstUse", + "webglGetLeftBracePos", + "emscriptenWebGLGetVertexAttrib", + "emscriptenWebGLGetBufferBinding", + "emscriptenWebGLValidateMapBufferTarget", + "writeGLArray", + "AL", + "SDL_unicode", + "SDL_ttfContext", + "SDL_audio", + "SDL", + "SDL_gfx", + "GLUT", + "EGL", + "GLFW_Window", + "GLFW", + "GLEW", + "IDBStore", + "runAndAbortIfError", + "emscriptenWebGLGetIndexed", + "WebGPU", + "JsValStore", + "ALLOC_NORMAL", + "ALLOC_STACK", + "allocate", + "InternalError", + "BindingError", + "UnboundTypeError", + "PureVirtualError", + "init_embind", + "throwInternalError", + "throwBindingError", + "throwUnboundTypeError", + "ensureOverloadTable", + "exposePublicSymbol", + "replacePublicSymbol", + "extendError", + "createNamedFunction", + "embindRepr", + "registeredInstances", + "getBasestPointer", + "registerInheritedInstance", + "unregisterInheritedInstance", + "getInheritedInstance", + "getInheritedInstanceCount", + "getLiveInheritedInstances", + "registeredTypes", + "awaitingDependencies", + "typeDependencies", + "registeredPointers", + "registerType", + "whenDependentTypesAreResolved", + "embind_charCodes", + "embind_init_charCodes", + "readLatin1String", + "getTypeName", + "heap32VectorToArray", + "requireRegisteredType", + "getShiftFromSize", + "integerReadValueFromPointer", + "enumReadValueFromPointer", + "floatReadValueFromPointer", + "simpleReadValueFromPointer", + "runDestructors", + "new_", + "craftInvokerFunction", + "embind__requireFunction", + "tupleRegistrations", + "structRegistrations", + "genericPointerToWireType", + "constNoSmartPtrRawPointerToWireType", + "nonConstNoSmartPtrRawPointerToWireType", + "init_RegisteredPointer", + "RegisteredPointer", + "RegisteredPointer_getPointee", + "RegisteredPointer_destructor", + "RegisteredPointer_deleteObject", + "RegisteredPointer_fromWireType", + "runDestructor", + "releaseClassHandle", + "finalizationRegistry", + "detachFinalizer_deps", + "detachFinalizer", + "attachFinalizer", + "makeClassHandle", + "init_ClassHandle", + "ClassHandle", + "ClassHandle_isAliasOf", + "throwInstanceAlreadyDeleted", + "ClassHandle_clone", + "ClassHandle_delete", + "deletionQueue", + "ClassHandle_isDeleted", + "ClassHandle_deleteLater", + "flushPendingDeletes", + "delayFunction", + "setDelayFunction", + "RegisteredClass", + "shallowCopyInternalPointer", + "downcastPointer", + "upcastPointer", + "validateThis", + "char_0", + "char_9", + "makeLegalFunctionName", + "emval_handle_array", + "emval_free_list", + "emval_symbols", + "init_emval", + "count_emval_handles", + "get_first_emval", + "getStringOrSymbol", + "Emval", + "emval_newers", + "craftEmvalAllocator", + "emval_get_global", + "emval_lookupTypes", + "emval_allocateDestructors", + "emval_methodCallers", + "emval_addMethodCaller", + "emval_registeredMethods", + ]; + unexportedRuntimeSymbols.forEach(unexportedRuntimeSymbol); + var missingLibrarySymbols = [ + "inetPton4", + "inetNtop4", + "inetPton6", + "inetNtop6", + "readSockaddr", + "writeSockaddr", + "getHostByName", + "traverseStack", + "convertPCtoSourceLocation", + "runMainThreadEmAsm", + "jstoi_s", + "listenOnce", + "autoResumeAudioContext", + "runtimeKeepalivePush", + "runtimeKeepalivePop", + "asmjsMangle", + "writeI53ToI64Clamped", + "writeI53ToI64Signaling", + "writeI53ToU64Clamped", + "writeI53ToU64Signaling", + "convertU32PairToI53", + "getCFunc", + "ccall", + "cwrap", + "uleb128Encode", + "sigToWasmTypes", + "generateFuncType", + "convertJsFunctionToWasm", + "getEmptyTableSlot", + "updateTableMap", + "addFunction", + "removeFunction", + "reallyNegative", + "unSign", + "strLen", + "reSign", + "formatString", + "intArrayToString", + "AsciiToString", + "stringToAscii", + "allocateUTF8OnStack", + "writeStringToMemory", + "getSocketFromFD", + "getSocketAddress", + "registerKeyEventCallback", + "getBoundingClientRect", + "fillMouseEventData", + "registerMouseEventCallback", + "registerWheelEventCallback", + "registerUiEventCallback", + "registerFocusEventCallback", + "fillDeviceOrientationEventData", + "registerDeviceOrientationEventCallback", + "fillDeviceMotionEventData", + "registerDeviceMotionEventCallback", + "screenOrientation", + "fillOrientationChangeEventData", + "registerOrientationChangeEventCallback", + "fillFullscreenChangeEventData", + "registerFullscreenChangeEventCallback", + "JSEvents_requestFullscreen", + "JSEvents_resizeCanvasForFullscreen", + "registerRestoreOldStyle", + "hideEverythingExceptGivenElement", + "restoreHiddenElements", + "setLetterbox", + "softFullscreenResizeWebGLRenderTarget", + "doRequestFullscreen", + "fillPointerlockChangeEventData", + "registerPointerlockChangeEventCallback", + "registerPointerlockErrorEventCallback", + "requestPointerLock", + "fillVisibilityChangeEventData", + "registerVisibilityChangeEventCallback", + "registerTouchEventCallback", + "fillGamepadEventData", + "registerGamepadEventCallback", + "registerBeforeUnloadEventCallback", + "fillBatteryEventData", + "battery", + "registerBatteryEventCallback", + "setCanvasElementSize", + "getCanvasElementSize", + "stackTrace", + "checkWasiClock", + "createDyncallWrapper", + "setImmediateWrapped", + "clearImmediateWrapped", + "polyfillSetImmediate", + "exception_addRef", + "exception_decRef", + "_setNetworkCallback", + "emscriptenWebGLGetUniform", + "emscriptenWebGLGetVertexAttrib", + "emscriptenWebGLGetBufferBinding", + "emscriptenWebGLValidateMapBufferTarget", + "writeGLArray", + "SDL_unicode", + "SDL_ttfContext", + "SDL_audio", + "GLFW_Window", + "runAndAbortIfError", + "emscriptenWebGLGetIndexed", + "ALLOC_NORMAL", + "ALLOC_STACK", + "allocate", + "enumReadValueFromPointer", + "craftEmvalAllocator", + ]; + missingLibrarySymbols.forEach(missingLibrarySymbol); + var calledRun; + dependenciesFulfilled = function runCaller() { + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; + }; + function stackCheckInit() { + _emscripten_stack_init(); + writeStackCookie(); + } + function run(args) { + args = args || arguments_; + if (runDependencies > 0) { + return; + } + stackCheckInit(); + preRun(); + if (runDependencies > 0) { + return; + } + function doRun() { + if (calledRun) return; + calledRun = true; + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + readyPromiseResolve(Module); + if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); + assert( + !Module["_main"], + 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]', + ); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(function () { + setTimeout(function () { + Module["setStatus"](""); + }, 1); + doRun(); + }, 1); + } else { + doRun(); + } + checkStackCookie(); + } + function checkUnflushedContent() { + var oldOut = out; + var oldErr = err; + var has = false; + out = err = (x) => { + has = true; + }; + try { + _fflush(0); + ["stdout", "stderr"].forEach(function (name) { + var info = FS.analyzePath("/dev/" + name); + if (!info) return; + var stream = info.object; + var rdev = stream.rdev; + var tty = TTY.ttys[rdev]; + if (tty && tty.output && tty.output.length) { + has = true; + } + }); + } catch (e) {} + out = oldOut; + err = oldErr; + if (has) { + warnOnce( + "stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.", + ); + } + } + if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]]; + while (Module["preInit"].length > 0) { + Module["preInit"].pop()(); + } + } + run(); + + return createMediapipeSolutionsWasm.ready; + }; +})(); +if (typeof exports === "object" && typeof module === "object") + module.exports = createMediapipeSolutionsWasm; +else if (typeof define === "function" && define["amd"]) + define([], function () { + return createMediapipeSolutionsWasm; + }); +else if (typeof exports === "object") + exports["createMediapipeSolutionsWasm"] = createMediapipeSolutionsWasm; diff --git a/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_wasm_bin.wasm b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_wasm_bin.wasm new file mode 100644 index 000000000..61d9c1815 Binary files /dev/null and b/public/mediapipe/selfie_segmentation/selfie_segmentation_solution_wasm_bin.wasm differ diff --git a/scripts/convert-selfie-segmentation-to-onnx.py b/scripts/convert-selfie-segmentation-to-onnx.py new file mode 100644 index 000000000..3cb617af2 --- /dev/null +++ b/scripts/convert-selfie-segmentation-to-onnx.py @@ -0,0 +1,137 @@ +#!/usr/bin/env python3 +"""Convert the vendored MediaPipe SelfieSegmentation .tflite to ONNX. + +This is the script that produced `selfie_segmentation_landscape.onnx`. It is checked in so +the artifact is reproducible and auditable rather than an opaque binary: the conversion is +NOT a mechanical one-liner, it needs two hand repairs (below), and anyone reviewing the model +needs to be able to see and re-run them. + +It is not part of any build. Nothing in the app runs Python; this is provenance tooling, run +by hand on the rare occasion the model is regenerated. + + pip install "numpy<2" "tensorflow==2.13.1" "tf2onnx==1.16.1" "onnx==1.16.2" "protobuf<4" + python scripts/convert-selfie-segmentation-to-onnx.py landscape + +Why the repairs are needed +-------------------------- +`tf2onnx` reports success on this model but leaves 12 operators that ONNX Runtime cannot load: + +1. **11 x HardSwish emitted into an opset-13 graph.** `HardSwish` is opset 14+, so the graph + is invalid as declared. Fixed by raising the opset to 16. + +2. **1 x TFL_Convolution2DTransposeBias** — a MediaPipe *custom* operator with no ONNX + equivalent, so tf2onnx passes it through under the default domain where it does not exist. + It is the last convolution before the output sigmoid: a 2x2 stride-2 transposed + convolution, 16 channels in, 1 out, plus a bias. Rewritten here as a native + `ConvTranspose` + bias, with the weights transposed from TFLite's + `[C_out, kH, kW, C_in]` to ONNX's `[C_in, C_out/group, kH, kW]`. + + tf2onnx also inserts an NHWC `Transpose` to feed that custom node. Since the replacement + consumes NCHW directly, the transpose is dropped and the layout flip moves after the + sigmoid (sigmoid is elementwise, so the order is equivalent). + +The result passes `onnx.checker.check_model(..., full_check=True)` and, on a real webcam +frame, produces a mask identical between the CPU and DirectML execution providers. + +The graph is fully convolutional and resolution-agnostic (every `Reshape` target is +channel-only, every `Resize` uses scales rather than sizes), so the input dimensions can be +rewritten after the fact -- but **both dimensions must be divisible by 16** or the +skip-connection `Add`s fail on mismatched extents. + +Source model: `public/mediapipe/selfie_segmentation/*.tflite`, vendored from MediaPipe +(Apache-2.0). This conversion is a derived work of that file; no weights are downloaded. +""" +import argparse +import pathlib +import subprocess +import sys + +import numpy as np +import onnx +from onnx import helper, numpy_helper, shape_inference + +HERE = pathlib.Path(__file__).resolve().parent +MODELS = HERE.parent / "public" / "mediapipe" / "selfie_segmentation" + +VARIANTS = { + "landscape": ("selfie_segmentation_landscape.tflite", "selfie_segmentation_landscape.onnx"), + "square": ("selfie_segmentation.tflite", "selfie_segmentation.onnx"), +} + + +def repair(src: pathlib.Path, dst: pathlib.Path) -> None: + model = onnx.load(str(src)) + graph = model.graph + + for opset in model.opset_import: + if opset.domain in ("", "ai.onnx"): + opset.version = 16 # HardSwish is opset 14+ + + init = {i.name: numpy_helper.to_array(i) for i in graph.initializer} + custom = next(n for n in graph.node if n.op_type == "TFL_Convolution2DTransposeBias") + feed_transpose = next(n for n in graph.node if n.output[0] == custom.input[0]) + source = feed_transpose.input[0] # NCHW feature map + sigmoid = next(n for n in graph.node if custom.output[0] in n.input) + assert sigmoid.op_type == "Sigmoid", sigmoid.op_type + + weights = init[custom.input[1]] # [C_out, kH, kW, C_in] + assert weights.shape == (1, 2, 2, 16), weights.shape + graph.initializer.append( + numpy_helper.from_array(np.transpose(weights, (3, 0, 1, 2)).copy(), "convT_W") + ) + + out_name = graph.output[0].name + nodes = [n for n in graph.node if n not in (feed_transpose, custom, sigmoid)] + nodes += [ + helper.make_node( + "ConvTranspose", [source, "convT_W", custom.input[2]], ["convT_out"], + name="conv2d_transpose_native", + kernel_shape=[2, 2], strides=[2, 2], pads=[0, 0, 0, 0], + ), + helper.make_node("Sigmoid", ["convT_out"], ["mask_nchw"], name="segment_sigmoid"), + helper.make_node("Transpose", ["mask_nchw"], [out_name], name="mask_to_nhwc", + perm=[0, 2, 3, 1]), + ] + del graph.node[:] + graph.node.extend(nodes) + del graph.value_info[:] + + model = shape_inference.infer_shapes(model, strict_mode=True) + onnx.checker.check_model(model, full_check=True) + onnx.save(model, str(dst)) + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("variant", choices=sorted(VARIANTS), nargs="?", default="landscape") + args = parser.parse_args() + + tflite_name, onnx_name = VARIANTS[args.variant] + tflite = MODELS / tflite_name + if not tflite.exists(): + print(f"missing source model: {tflite}", file=sys.stderr) + return 1 + + raw = MODELS / f".{onnx_name}.raw" + subprocess.run( + [sys.executable, "-m", "tf2onnx.convert", "--tflite", str(tflite), + "--output", str(raw), "--opset", "13"], + check=True, + ) + # tf2onnx exits 0 while leaving 12 unloadable operators behind -- see the module docstring. + repair(raw, MODELS / onnx_name) + raw.unlink(missing_ok=True) + + model = onnx.load(str(MODELS / onnx_name)) + gi, go = model.graph.input[0], model.graph.output[0] + shape = lambda v: [d.dim_value for d in v.type.tensor_type.shape.dim] + leftover = [n.op_type for n in model.graph.node if n.domain not in ("", "ai.onnx")] + print(f"wrote {MODELS / onnx_name}") + print(f" input {gi.name} {shape(gi)}") + print(f" output {go.name} {shape(go)}") + print(f" nodes {len(model.graph.node)} non-standard ops: {leftover or 'none'}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/cli/CliExportRunner.tsx b/src/cli/CliExportRunner.tsx index 31f12233e..9aa47d46d 100644 --- a/src/cli/CliExportRunner.tsx +++ b/src/cli/CliExportRunner.tsx @@ -27,6 +27,7 @@ import { assetCameraSource } from "@/lib/ai-edition/timeline/camera"; import { resolveClipSourceEndSec } from "@/lib/ai-edition/timeline/clipDuration"; import { DEFAULT_ZOOM_DEPTH, ZOOM_DEPTH_SCALES } from "@/lib/ai-edition/timeline/zoom-scale"; import { buildAutoZoomSuggestions } from "@/lib/ai-edition/timeline/zoom-suggestions"; +import { applySegmentedWebcamTracks } from "@/lib/ai-edition/webcamSegmentation"; import type { CliDoneResult, CliExportRequest } from "@/lib/cliContracts"; import { GIF_SIZE_PRESETS, type GifSizePreset } from "@/lib/exporter"; import { calculateMp4ExportSettings } from "@/lib/exporter/mp4ExportSettings"; @@ -263,11 +264,30 @@ async function runExport(request: CliExportRequest): Promise { aspectRatioValue, }); - const clips = buildNativeClipList(axcutDocument); - if (clips.length === 0) { + const builtClips = buildNativeClipList(axcutDocument); + if (builtClips.length === 0) { throw new Error("The project's timeline has no visible clips to export"); } - const sceneJson = JSON.stringify(buildSceneDescription(axcutDocument)); + const sceneDesc = buildSceneDescription(axcutDocument); + const settings = getEditorSettings(axcutDocument); + + const clips = await applySegmentedWebcamTracks( + builtClips, + { + mode: settings.webcamBackgroundMode, + blurIntensity: settings.webcamBlurIntensity, + wallpaper: settings.webcamWallpaper, + }, + (prog) => { + window.electronAPI.cliProgress({ + percentage: Math.min(100, prog * 100), + currentFrame: Math.round(prog * 100), + totalFrames: 100, + estimatedTimeRemaining: 0, + }); + }, + ); + const sceneJson = JSON.stringify(sceneDesc); // Progress: native pushes raw encoded-frame counts; totals and pacing are // computed here, mirroring the ExportDialog. diff --git a/src/components/ai-edition/ExportDialog.tsx b/src/components/ai-edition/ExportDialog.tsx index c661933f1..ad618ad13 100644 --- a/src/components/ai-edition/ExportDialog.tsx +++ b/src/components/ai-edition/ExportDialog.tsx @@ -22,6 +22,7 @@ import type { AxcutDocument } from "@/lib/ai-edition/schema"; import { getEditorSettings } from "@/lib/ai-edition/store/editorSettings"; import { assetCameraSource } from "@/lib/ai-edition/timeline/camera"; import { resolveClipSourceEndSec } from "@/lib/ai-edition/timeline/clipDuration"; +import { applySegmentedWebcamTracks } from "@/lib/ai-edition/webcamSegmentation"; import { type ExportFormat, type ExportProgress, @@ -309,14 +310,34 @@ export function ExportDialog({ open, onClose, document }: ExportDialogProps) { }); }); try { - const sceneJson = JSON.stringify(buildSceneDescription(document)); + const sceneDesc = buildSceneDescription(document); + const settings = getEditorSettings(document); + + const exportClips = await applySegmentedWebcamTracks( + clips, + { + mode: settings.webcamBackgroundMode, + blurIntensity: settings.webcamBlurIntensity, + wallpaper: settings.webcamWallpaper, + }, + (prog) => { + setProgress({ + currentFrame: Math.round(prog * 100), + totalFrames: 100, + percentage: Math.round(prog * 100), + estimatedTimeRemaining: 0, + }); + }, + ); + + const sceneJson = JSON.stringify(sceneDesc); const outDims = tierOutputDims(quality); - if (clips.length === 0) { + if (exportClips.length === 0) { throw new Error(t("exportDialog.nothingToExport")); } const stats = format === "gif" - ? await exportGifNative(clips, pickedPath, sceneJson, { + ? await exportGifNative(exportClips, pickedPath, sceneJson, { // GIF is 256-colour and grows fast; cap the long edge at the // chosen preset rather than exporting at source size. ...gifOutputDims(gifSize, outDims), @@ -324,7 +345,7 @@ export function ExportDialog({ open, onClose, document }: ExportDialogProps) { // 0 = infinite, the historical GIF default; 1 = play once. loopCount: gifLoop ? 0 : 1, }) - : await exportMultiNative(clips, pickedPath, sceneJson, { + : await exportMultiNative(exportClips, pickedPath, sceneJson, { width: outDims?.width, height: outDims?.height, fps, diff --git a/src/components/ai-edition/NativeCompositorOverlay.tsx b/src/components/ai-edition/NativeCompositorOverlay.tsx index 710e90c74..75029c1f0 100644 --- a/src/components/ai-edition/NativeCompositorOverlay.tsx +++ b/src/components/ai-edition/NativeCompositorOverlay.tsx @@ -81,6 +81,25 @@ export function NativeCompositorOverlay() { // `null` = document pas encore chargé (on attend) ; `{}` = chargé sans asset (→ fixture) ; // `{screenPath,…}` = vraies sources de l'asset primaire. + const settings = useMemo(() => getEditorSettings(document), [document]); + + // The real camera path, independent of whether NATIVE is the one drawing it: the scene + // still needs it to look up the probed webcam size, which shapes the PiP box. + const cameraPath = useMemo(() => { + if (!document) return undefined; + const primary = + document.assets.find((a) => a.id === document.project.primaryAssetId) ?? document.assets[0]; + return primary ? assetCameraSource(primary).path || undefined : undefined; + }, [document]); + + // With a background effect on, WebcamOverlay's segmentation canvas paints the camera + // (background included) over this slot. Handing the same camera to the native view too + // would draw the RAW frame underneath it — invisible behind an opaque blur/custom + // result, but plainly visible through the alpha of a transparent cut-out, which made + // cut-out mode look like it did nothing. Withholding the source is what makes the app + // the sole owner of that layer; `has_webcam` gates only the draw, never the layout. + const appOwnsWebcamLayer = settings.webcamBackgroundMode !== "none"; + const sources = useMemo(() => { if (!document) { return null; @@ -95,13 +114,13 @@ export function NativeCompositorOverlay() { // the one accessor, so it can never disagree with the scene or the export. return { screenPath: primary.originalPath, - webcamPath: assetCameraSource(primary).path || undefined, + webcamPath: appOwnsWebcamLayer ? undefined : assetCameraSource(primary).path || undefined, // sidecar convention (electron/ipc/handlers.ts readCursorRecordingFile) : la // télémétrie curseur vit à côté de la vidéo tant qu'elle n'a pas bougé. Absente → // le natif ignore juste le curseur (CursorTrack::load échoue silencieusement). cursorPath: `${primary.originalPath}.cursor.json`, }; - }, [document]); + }, [document, appOwnsWebcamLayer]); const ready = sources !== null; const { viewId, error } = useNativeCompositorView(canvasRef, { @@ -132,8 +151,10 @@ export function NativeCompositorOverlay() { return; } try { - const activeWebcamPath = sources && "webcamPath" in sources ? sources.webcamPath : undefined; - const webcamSourceSize = activeWebcamPath ? getWebcamNativeSize(activeWebcamPath) : null; + // Deliberately `cameraPath`, not `sources.webcamPath`: the latter is withheld + // while the app owns the webcam layer, and losing the probed size here would + // reshape the PiP box out from under the segmentation canvas that fills it. + const webcamSourceSize = cameraPath ? getWebcamNativeSize(cameraPath) : null; const scene = buildSceneDescription(document, webcamSourceSize); setNativeScene(JSON.stringify(scene)); } catch (error) { @@ -164,7 +185,6 @@ export function NativeCompositorOverlay() { // n'a pas d'importance. Et ca ne peut pas lutter contre un drag de slider : // `setLive` passe par `setDocument`, donc `document` a deja la NOUVELLE // valeur a chaque tick -- la meme que celle que le handler vient de pousser. - const settings = useMemo(() => getEditorSettings(document), [document]); useEffect(() => { const push = () => pushAllNativeParams(settings); push(); diff --git a/src/components/ai-edition/NewEditorShell.module.css b/src/components/ai-edition/NewEditorShell.module.css index c842a535a..c9dc9e087 100644 --- a/src/components/ai-edition/NewEditorShell.module.css +++ b/src/components/ai-edition/NewEditorShell.module.css @@ -845,6 +845,16 @@ visibility: hidden; display: block; } +.webcamSlot .webcamCanvas { + width: 100%; + height: 100%; + object-fit: cover; + visibility: visible; + display: block; + position: absolute; + inset: 0; + z-index: 1; +} /* ─── transport bar (lives inside .timelineHead, next to the tool icons) ─ */ .transport { display: flex; diff --git a/src/components/ai-edition/RightPanes.tsx b/src/components/ai-edition/RightPanes.tsx index d12fe248a..4efb3ef20 100644 --- a/src/components/ai-edition/RightPanes.tsx +++ b/src/components/ai-edition/RightPanes.tsx @@ -214,60 +214,22 @@ export function isSupportedBackgroundImage(type: string, fileName: string): bool return IMAGE_EXTENSIONS.some((extension) => name.endsWith(extension)); } -// Wallpaper picker — image / solid color / gradient tabs. -// -// Wallpapers round-trip through the legacyEditor envelope exactly as they did -// in the v2 editor: gradient strings stay as-is, colors as `#hex`, and image -// paths are restricted to `/wallpapers/...` or the user's own data: URLs from -// the upload custom flow. -function BackgroundSection() { +/** + * The "upload custom wallpaper" concern: a hidden `` plus the reader + * that turns the pick into a `data:` URL. + * + * A hook rather than part of `WallpaperPicker` because WHERE the input may be mounted is + * the caller's problem. `BackgroundSection` renders the picker inside a Popover, and + * opening the OS file dialog takes focus, which closes the Popover — an input mounted + * inside it would unmount mid-pick and drop the file. That caller mounts `input` outside + * the Popover; inline callers mount it next to the picker. + */ +function useWallpaperFileInput(onPicked: (dataUrl: string) => void): { + pick: () => void; + input: ReactNode; +} { const ts = useScopedT("settings"); - const { settings, set, setLive, commit, hasDocument } = useEditorSettings(); - const [pickerOpen, setPickerOpen] = useState(false); - // Seeded from what the project is actually using, so the picker opens on the tab the - // user is already in rather than always on Image. - const [tab, setTab] = useState<"image" | "color" | "gradient">( - () => classifyWallpaper(settings.wallpaper).kind, - ); - const fileInputRef = useRef(null); - const customUrls = useMemoCustomWallpapers(settings.wallpaper); - - // The custom gradient editor emits continuously while the user drags a - // color point / angle knob / brightness slider, so mirror the SliderCell - // model: preview live with setLive, then persist once the changes settle. - const gradientCommitTimer = useRef(null); - const handleGradientChange = useCallback( - (state: GradientEditorState) => { - setLive({ wallpaper: buildGradientFromEditor(state) }); - if (gradientCommitTimer.current !== null) { - window.clearTimeout(gradientCommitTimer.current); - } - gradientCommitTimer.current = window.setTimeout(() => { - gradientCommitTimer.current = null; - void commit(); - }, 400); - }, - [setLive, commit], - ); - useEffect( - () => () => { - if (gradientCommitTimer.current !== null) { - window.clearTimeout(gradientCommitTimer.current); - } - }, - [], - ); - - const isSelected = (value: string) => settings.wallpaper === value; - - const handleTabChange = (next: "image" | "color" | "gradient") => { - setTab(next); - }; - - const handlePickFile = () => { - if (!hasDocument) return; - fileInputRef.current?.click(); - }; + const ref = useRef(null); const handleFileSelected = (e: ChangeEvent) => { const file = e.target.files?.[0]; @@ -284,12 +246,40 @@ function BackgroundSection() { toast.error(ts("background.imageReadFailed")); return; } - void set({ wallpaper: dataUrl }); + onPicked(dataUrl); }; reader.onerror = () => toast.error(ts("background.imageReadFailed")); reader.readAsDataURL(file); }; + return { + pick: () => ref.current?.click(), + input: ( + + ), + }; +} + +// Wallpaper picker — image / solid color / gradient tabs. +// +// Wallpapers round-trip through the legacyEditor envelope exactly as they did +// in the v2 editor: gradient strings stay as-is, colors as `#hex`, and image +// paths are restricted to `/wallpapers/...` or the user's own data: URLs from +// the upload custom flow. +function BackgroundSection() { + const ts = useScopedT("settings"); + const { settings, set, setLive, commit, hasDocument } = useEditorSettings(); + const [pickerOpen, setPickerOpen] = useState(false); + const { pick: handlePickFile, input: fileInput } = useWallpaperFileInput((dataUrl) => + set({ wallpaper: dataUrl }), + ); + return ( <>
{ts("background.title")}
@@ -328,117 +318,21 @@ function BackgroundSection() { className="w-auto border-0 bg-transparent p-0 shadow-none" >
- {/* role="tab" + aria-selected are what make the tablist above mean - anything: without them a screen reader announces three plain - buttons and never says which one is current. */} -
- - - -
- {tab === "image" ? ( - <> - -
- {customUrls.map((url) => ( -
- - ) : tab === "color" ? ( - void set({ wallpaper: color })} - /> - ) : ( - <> -
- {GRAD_PRESETS.map((bg, i) => ( -
- {hasDocument ? : null} - - )} + void set({ wallpaper: url })} + onLiveChange={(url) => setLive({ wallpaper: url })} + onCommit={commit} + onPickFile={handlePickFile} + />
{/* Stays mounted OUTSIDE the popover: opening the OS file dialog takes focus, which closes the popover and would unmount the input mid-pick, dropping the file. It has no layout to cost us here. */} - + {fileInput} {/* Reads in the order it acts: pick a background, then blur it. Lived under "Effects" while that was a separate facet, which is how a control named "Blur BG" ended up in the tab that doesn't say background. */} @@ -502,16 +396,26 @@ function useMemoCustomWallpapers(current: string): string[] { return cached; } +function normaliseHex(raw: string): string | null { + const trimmed = raw.trim(); + if (!trimmed) return null; + const withHash = trimmed.startsWith("#") ? trimmed : `#${trimmed}`; + if (!/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(withHash)) return null; + return withHash.toLowerCase(); +} + function BackgroundColorTab({ value, hasDocument, isSelected, onPick, + updateNative = true, }: { value: string; hasDocument: boolean; isSelected: (v: string) => boolean; onPick: (next: string) => void; + updateNative?: boolean; }) { const ts = useScopedT("settings"); const [hexDraft, setHexDraft] = useState(value.startsWith("#") ? value : "#000000"); @@ -522,7 +426,7 @@ function BackgroundColorTab({ const next = normaliseHex(hexDraft); if (next) { onPick(next); - if (isNativeCompositorActive()) { + if (updateNative && isNativeCompositorActive()) { setNativeParam("backgroundColor", next); } } @@ -540,7 +444,7 @@ function BackgroundColorTab({ disabled={!hasDocument} onClick={() => { onPick(c); - if (isNativeCompositorActive()) { + if (updateNative && isNativeCompositorActive()) { setNativeParam("backgroundColor", c); } }} @@ -595,12 +499,166 @@ function BackgroundColorTab({ ); } -function normaliseHex(raw: string): string | null { - const trimmed = raw.trim(); - if (!trimmed) return null; - const withHash = trimmed.startsWith("#") ? trimmed : `#${trimmed}`; - if (!/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(withHash)) return null; - return withHash.toLowerCase(); +export interface WallpaperPickerProps { + value: string; + hasDocument: boolean; + onChange: (val: string) => void; + onLiveChange?: (val: string) => void; + onCommit?: () => void; + updateNativeBackground?: boolean; + /** Opens the OS file dialog. The hidden `` it clicks belongs to the caller + * (see `useWallpaperFileInput`): where it may be mounted depends on the caller. */ + onPickFile: () => void; +} + +export function WallpaperPicker({ + value, + hasDocument, + onChange, + onLiveChange, + onCommit, + updateNativeBackground = true, + onPickFile, +}: WallpaperPickerProps) { + const ts = useScopedT("settings"); + // Seeded from what is actually in use, so the picker opens on the tab the user is + // already in rather than always on Image. + const [tab, setTab] = useState<"image" | "color" | "gradient">( + () => classifyWallpaper(value).kind, + ); + const customUrls = useMemoCustomWallpapers(value); + + const gradientCommitTimer = useRef(null); + const handleGradientChange = useCallback( + (state: GradientEditorState) => { + const grad = buildGradientFromEditor(state); + if (onLiveChange) onLiveChange(grad); + else onChange(grad); + if (gradientCommitTimer.current !== null) { + window.clearTimeout(gradientCommitTimer.current); + } + gradientCommitTimer.current = window.setTimeout(() => { + gradientCommitTimer.current = null; + if (onCommit) void onCommit(); + }, 400); + }, + [onChange, onLiveChange, onCommit], + ); + useEffect( + () => () => { + if (gradientCommitTimer.current !== null) { + window.clearTimeout(gradientCommitTimer.current); + } + }, + [], + ); + + const isSelected = (candidate: string) => value === candidate; + + const handleTabChange = (next: "image" | "color" | "gradient") => { + setTab(next); + }; + + return ( + <> + {/* role="tab" + aria-selected are what make the tablist mean anything: without + them a screen reader announces three plain buttons and never says which one + is current. */} +
+ + + +
+ {tab === "image" ? ( + <> + +
+ {customUrls.map((url) => ( +
+ + ) : tab === "color" ? ( + onChange(color)} + updateNative={updateNativeBackground} + /> + ) : ( + <> +
+ {GRAD_PRESETS.map((bg, i) => ( +
+ {hasDocument ? : null} + + )} + + ); } /** Which clip a transcript cut lands on. The clip id is what makes the cut land on ONE @@ -1828,9 +1886,55 @@ const CAMERA_SHAPES: Array<{ }, ]; +const CAMERA_BACKGROUND_MODES: Array<{ + value: "none" | "transparent" | "blur" | "custom"; + labelKey: string; + icon: ReactNode; +}> = [ + { + value: "none", + labelKey: "layout.bgModes.none", + icon: , + }, + { + value: "transparent", + labelKey: "layout.bgModes.transparent", + icon: ( + <> + + + + ), + }, + { + value: "blur", + labelKey: "layout.bgModes.blur", + icon: ( + <> + + + + ), + }, + { + value: "custom", + labelKey: "layout.bgModes.custom", + icon: ( + <> + + + + + ), + }, +]; + export function LayoutPane() { const ts = useScopedT("settings"); const { settings, set, setLive, commit, hasDocument } = useEditorSettings(); + const { pick: handlePickWebcamWallpaper, input: webcamWallpaperInput } = useWallpaperFileInput( + (dataUrl) => set({ webcamWallpaper: dataUrl }), + ); const document = useProjectStore((s) => s.document); // A project can hold clips with no camera attached at all (plain imports or a // recording made without a webcam). Keep the saved camera preference for later, but @@ -2031,6 +2135,78 @@ export function LayoutPane() { ) : null} +
{ts("layout.webcamBackground")}
+
+ {CAMERA_BACKGROUND_MODES.map((mode) => { + const isActive = settings.webcamBackgroundMode === mode.value; + return ( + + ); + })} +
+ {settings.webcamBackgroundMode === "blur" ? ( +
+ setLive({ webcamBlurIntensity: next / 100 })} + onCommit={() => void commit()} + /> +
+ ) : null} + {settings.webcamBackgroundMode === "custom" ? ( +
+ void set({ webcamWallpaper: url })} + onLiveChange={(url) => setLive({ webcamWallpaper: url })} + onCommit={commit} + updateNativeBackground={false} + onPickFile={handlePickWebcamWallpaper} + /> + {webcamWallpaperInput} +
+ ) : null}
{ts("layout.webcamFraming")}
{ afterEach(() => { cleanup(); @@ -154,4 +177,49 @@ describe("WebcamOverlay (per-clip camera resolution)", () => { rerender(); expect(container.querySelector("video")).toBeTruthy(); }); + + // The background is painted INTO the segmentation canvas (colour, gradient and image + // alike), which is also what gets encoded for export — so the canvas being mounted is + // what "the effect is on" means. An extra CSS background layer used to sit behind it + // and was either invisible or a second, differently-painted copy of the same wallpaper. + it("mounts the segmentation canvas when a webcam background mode is active", () => { + const doc = makeDocument(); + doc.legacyEditor = { ...baseLegacyEditor, webcamBackgroundMode: "custom" }; + useProjectStore.setState({ + projectId: "proj_test", + document: doc, + revision: 1, + status: "ready", + error: null, + sourceDurationSec: 0, + currentTimeSec: 2, + dirty: false, + lastSavedAt: new Date(), + }); + + const { container } = render(); + // The