From 631b2cdf4b5ef7ee07b7ce8a7443a4827c63dcaa Mon Sep 17 00:00:00 2001
From: Matthieu Baumann <matthieu.baumann@astro.unistra.fr>
Date: Mon, 1 Jul 2024 09:41:49 +0200
Subject: [PATCH] WIP: polyline catalog renderer

---
 examples/al-init-custom-options.html      |   3 +-
 src/core/Cargo.toml                       |   2 +-
 src/core/src/lib.rs                       |   7 +-
 src/core/src/math/angle.rs                |   4 +-
 src/core/src/math/lonlat.rs               |   5 +-
 src/core/src/renderable/line/mod.rs       |  32 +---
 src/core/src/renderable/moc/renderer.rs   | 137 --------------
 src/core/src/renderable/mod.rs            |   1 +
 src/core/src/renderable/shape/box.rs      |   1 +
 src/core/src/renderable/shape/circle.rs   |   0
 src/core/src/renderable/shape/ellipsis.rs |   0
 src/core/src/renderable/shape/image.rs    |   0
 src/core/src/renderable/shape/mod.rs      |  62 +++++++
 src/core/src/renderable/shape/polyline.rs | 210 ++++++++++++++++++++++
 src/js/Aladin.js                          |   2 +
 src/js/View.js                            |   2 +
 16 files changed, 289 insertions(+), 179 deletions(-)
 create mode 100644 src/core/src/renderable/shape/box.rs
 create mode 100644 src/core/src/renderable/shape/circle.rs
 create mode 100644 src/core/src/renderable/shape/ellipsis.rs
 create mode 100644 src/core/src/renderable/shape/image.rs
 create mode 100644 src/core/src/renderable/shape/mod.rs
 create mode 100644 src/core/src/renderable/shape/polyline.rs

diff --git a/examples/al-init-custom-options.html b/examples/al-init-custom-options.html
index 1dc967616..8e0930108 100644
--- a/examples/al-init-custom-options.html
+++ b/examples/al-init-custom-options.html
@@ -7,10 +7,9 @@
 
 
 <div id="aladin-lite-div" style="width: 768px; height: 512px"></div>
-
+<script>let aladin;</script>
 <script type="module">
     import A from '../src/js/A.js';
-    let aladin;
     A.init.then(() => {
         aladin = A.aladin(
             '#aladin-lite-div',
diff --git a/src/core/Cargo.toml b/src/core/Cargo.toml
index 4305fc521..cd64f9586 100644
--- a/src/core/Cargo.toml
+++ b/src/core/Cargo.toml
@@ -29,7 +29,7 @@ mapproj = "0.3.0"
 fitsrs = "0.2.9"
 wcs = "0.2.8"
 colorgrad = "0.6.2"
-lyon = "1.0.1"
+#lyon = "1.0.1"
 console_error_panic_hook = {version = "0.1.7", optional = true}
 
 [features]
diff --git a/src/core/src/lib.rs b/src/core/src/lib.rs
index 4418587fe..4c0a3ef15 100644
--- a/src/core/src/lib.rs
+++ b/src/core/src/lib.rs
@@ -165,12 +165,7 @@ impl WebClient {
 
         let shaders = ShaderManager::new().unwrap_abort();
 
-        // Event listeners callbacks
-        //let callback_position_changed = js_sys::Function::new_no_args("");
-        let app = App::new(
-            &gl, aladin_div, shaders, resources,
-            //callback_position_changed,
-        )?;
+        let app = App::new(&gl, aladin_div, shaders, resources)?;
 
         let dt = DeltaTime::zero();
 
diff --git a/src/core/src/math/angle.rs b/src/core/src/math/angle.rs
index 6bd271eb9..f7ecc660b 100644
--- a/src/core/src/math/angle.rs
+++ b/src/core/src/math/angle.rs
@@ -24,6 +24,7 @@ where
 }
 
 use cgmath::{Deg, Rad};
+use serde::Deserialize;
 // Convert a Rad<T> to an ArcDeg<T>
 impl<T> From<Rad<T>> for ArcDeg<T>
 where
@@ -362,7 +363,8 @@ impl FormatType for HMS {
     }
 }
 
-#[derive(Clone, Copy, Debug, Eq, Hash)]
+#[derive(Clone, Copy, Debug, Eq, Hash, Deserialize)]
+#[serde(rename_all = "camelCase")]
 #[repr(C)]
 pub struct Angle<S: BaseFloat>(pub S);
 impl<S> Angle<S>
diff --git a/src/core/src/math/lonlat.rs b/src/core/src/math/lonlat.rs
index f499d8139..79b4cc5a7 100644
--- a/src/core/src/math/lonlat.rs
+++ b/src/core/src/math/lonlat.rs
@@ -8,9 +8,10 @@ pub trait LonLat<S: BaseFloat> {
     fn lonlat(&self) -> LonLatT<S>;
     fn from_lonlat(lonlat: &LonLatT<S>) -> Self;
 }
-
 use crate::math::angle::Angle;
-#[derive(Clone, Copy, Debug)]
+use serde::Deserialize;
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
 #[repr(C)]
 pub struct LonLatT<S: BaseFloat>(pub Angle<S>, pub Angle<S>);
 
diff --git a/src/core/src/renderable/line/mod.rs b/src/core/src/renderable/line/mod.rs
index d6167b669..c4896540f 100644
--- a/src/core/src/renderable/line/mod.rs
+++ b/src/core/src/renderable/line/mod.rs
@@ -4,7 +4,6 @@ pub mod parallel_arc;
 
 use crate::math::projection::ProjectionType;
 use crate::shader::ShaderManager;
-use crate::Abort;
 use al_api::coo_system::CooSystem;
 use al_core::VertexArrayObject;
 use al_core::WebGlContext;
@@ -13,8 +12,6 @@ use super::Renderer;
 use al_api::color::ColorRGBA;
 use al_core::SliceData;
 
-use lyon::algorithms::{math::point, path::Path};
-
 struct Meta {
     color: ColorRGBA,
     thickness: f32,
@@ -50,33 +47,8 @@ use web_sys::WebGl2RenderingContext;
 
 use crate::camera::CameraViewPort;
 
-use lyon::tessellation::*;
-
 use crate::coo_space::CooSpace;
 
-/*impl<S: BaseFloat> GPUVertexAttribute<S> for XYZModel<S> {
-    const Space: CooSpace = CooSpace::Model;
-
-    fn as_ref(&self) -> &[S] {
-        &self[..]
-    }
-}
-impl<S: BaseFloat> GPUVertexAttribute<S> for LonLatT<S> {
-    const Space: CooSpace = CooSpace::LonLat;
-
-    fn as_ref(&self) -> &[S] {
-        let addr = self as *const LonLatT<S> as *const S;
-        unsafe { std::slice::from_raw_parts(addr, 2) }
-    }
-}*/
-/*
-impl<S: BaseFloat> GPUVertexAttribute for XYZModel<S> {
-    const Space: CooSpace = CooSpace::Model;
-}
-impl<S: BaseFloat> GPUVertexAttribute for LonLatT<S> {
-    const Space: CooSpace = CooSpace::LonLat;
-}*/
-
 #[repr(C)]
 pub struct PathVertices<V>
 where
@@ -126,7 +98,7 @@ impl RasterizedLineRenderer {
         })
     }
 
-    pub fn add_fill_paths<V>(
+    /*pub fn add_fill_paths<V>(
         &mut self,
         paths: impl Iterator<Item = PathVertices<V>>,
         color: &ColorRGBA,
@@ -200,7 +172,7 @@ impl RasterizedLineRenderer {
             color: color.clone(),
             coo_space,
         });
-    }
+    }*/
 
     fn create_instanced_vao(&mut self) {
         let mut vao = VertexArrayObject::new(&self.gl);
diff --git a/src/core/src/renderable/moc/renderer.rs b/src/core/src/renderable/moc/renderer.rs
index f8b25f717..42ab70b2d 100644
--- a/src/core/src/renderable/moc/renderer.rs
+++ b/src/core/src/renderable/moc/renderer.rs
@@ -16,143 +16,6 @@ pub struct MOCRenderer {
     gl: WebGlContext,
 }
 
-/*
-use cgmath::Vector2;
-use super::utils::triangle::Triangle;
-fn is_crossing_projection(
-    cell: &HEALPixCell,
-    camera: &CameraViewPort,
-    projection: &ProjectionType,
-) -> bool {
-    let vertices = cell
-        .vertices()
-        .iter()
-        .filter_map(|(lon, lat)| {
-            let xyzw = crate::math::lonlat::radec_to_xyzw(Angle(*lon), Angle(*lat));
-            let xyzw =
-                crate::coosys::apply_coo_system(CooSystem::ICRS, camera.get_coo_system(), &xyzw);
-
-            projection
-                .model_to_normalized_device_space(&xyzw, camera)
-                .map(|v| [v.x as f32, v.y as f32])
-        })
-        .collect::<Vec<_>>();
-
-    let cell_inside = vertices.len() == 4;
-
-    if cell_inside {
-        let c0 = &vertices[0];
-        let c1 = &vertices[1];
-        let c2 = &vertices[2];
-        let c3 = &vertices[3];
-
-        let t0 = Triangle::new(c0, c1, c2);
-        let t2 = Triangle::new(c2, c3, c0);
-
-        t0.is_invalid(camera) || t2.is_invalid(camera)
-    } else {
-        true
-    }
-}
-
-use al_api::cell::HEALPixCellProjeted;
-fn rasterize_hpx_cell(
-    cell: &HEALPixCell,
-    n_segment_by_side: usize,
-    camera: &CameraViewPort,
-    idx_off: &mut u32,
-    proj: &ProjectionType,
-) -> Option<(Vec<f32>, Vec<u32>)> {
-    let n_vertices_per_segment = n_segment_by_side + 1;
-
-    let vertices = cell
-        .grid(n_segment_by_side as u32)
-        .iter()
-        .filter_map(|(lon, lat)| {
-            let xyzw = crate::math::lonlat::radec_to_xyzw(Angle(*lon), Angle(*lat));
-            let xyzw =
-                crate::coosys::apply_coo_system(CooSystem::ICRS, camera.get_coo_system(), &xyzw);
-
-            proj.model_to_normalized_device_space(&xyzw, camera)
-                .map(|v| [v.x as f32, v.y as f32])
-        })
-        .flatten()
-        .collect::<Vec<_>>();
-
-    let cell_inside = vertices.len() == 2 * (n_segment_by_side + 1) * (n_segment_by_side + 1);
-
-    if cell_inside {
-        // Generate the iterator: idx_off + 1, idx_off + 1, .., idx_off + 4*n_segment - 1, idx_off + 4*n_segment - 1
-        let mut indices = Vec::with_capacity(n_segment_by_side * n_segment_by_side * 6);
-        let num_vertices = (n_segment_by_side + 1) * (n_segment_by_side + 1);
-
-        let longitude_reversed = camera.get_longitude_reversed();
-        let invalid_tri = |tri_ccw: bool, reversed_longitude: bool| -> bool {
-            (!reversed_longitude && !tri_ccw) || (reversed_longitude && tri_ccw)
-        };
-
-        for i in 0..n_segment_by_side {
-            for j in 0..n_segment_by_side {
-                let idx_0 = j + i * n_vertices_per_segment;
-                let idx_1 = j + 1 + i * n_vertices_per_segment;
-                let idx_2 = j + (i + 1) * n_vertices_per_segment;
-                let idx_3 = j + 1 + (i + 1) * n_vertices_per_segment;
-
-                let c0 = crate::math::projection::ndc_to_screen_space(
-                    &Vector2::new(vertices[2 * idx_0] as f64, vertices[2 * idx_0 + 1] as f64),
-                    camera,
-                );
-                let c1 = crate::math::projection::ndc_to_screen_space(
-                    &Vector2::new(vertices[2 * idx_1] as f64, vertices[2 * idx_1 + 1] as f64),
-                    camera,
-                );
-                let c2 = crate::math::projection::ndc_to_screen_space(
-                    &Vector2::new(vertices[2 * idx_2] as f64, vertices[2 * idx_2 + 1] as f64),
-                    camera,
-                );
-                let c3 = crate::math::projection::ndc_to_screen_space(
-                    &Vector2::new(vertices[2 * idx_3] as f64, vertices[2 * idx_3 + 1] as f64),
-                    camera,
-                );
-
-                let first_tri_ccw = !crate::math::vector::ccw_tri(&c0, &c1, &c2);
-                let second_tri_ccw = !crate::math::vector::ccw_tri(&c1, &c3, &c2);
-
-                if invalid_tri(first_tri_ccw, longitude_reversed)
-                    || invalid_tri(second_tri_ccw, longitude_reversed)
-                {
-                    return None;
-                }
-
-                let vx = [c0.x, c1.x, c2.x, c3.x];
-                let vy = [c0.y, c1.y, c2.y, c3.y];
-
-                let projeted_cell = HEALPixCellProjeted {
-                    ipix: cell.idx(),
-                    vx,
-                    vy,
-                };
-
-                crate::camera::view_hpx_cells::project(projeted_cell, camera, proj)?;
-
-                indices.push(*idx_off + idx_0 as u32);
-                indices.push(*idx_off + idx_1 as u32);
-                indices.push(*idx_off + idx_2 as u32);
-
-                indices.push(*idx_off + idx_1 as u32);
-                indices.push(*idx_off + idx_3 as u32);
-                indices.push(*idx_off + idx_2 as u32);
-            }
-        }
-
-        *idx_off += num_vertices as u32;
-
-        Some((vertices, indices))
-    } else {
-        None
-    }
-}*/
-
 use crate::ProjectionType;
 
 impl MOCRenderer {
diff --git a/src/core/src/renderable/mod.rs b/src/core/src/renderable/mod.rs
index b778be3db..9b3db4c54 100644
--- a/src/core/src/renderable/mod.rs
+++ b/src/core/src/renderable/mod.rs
@@ -5,6 +5,7 @@ pub mod hips;
 pub mod image;
 pub mod line;
 pub mod moc;
+pub mod shape;
 pub mod text;
 pub mod utils;
 
diff --git a/src/core/src/renderable/shape/box.rs b/src/core/src/renderable/shape/box.rs
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/src/core/src/renderable/shape/box.rs
@@ -0,0 +1 @@
+
diff --git a/src/core/src/renderable/shape/circle.rs b/src/core/src/renderable/shape/circle.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/core/src/renderable/shape/ellipsis.rs b/src/core/src/renderable/shape/ellipsis.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/core/src/renderable/shape/image.rs b/src/core/src/renderable/shape/image.rs
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/core/src/renderable/shape/mod.rs b/src/core/src/renderable/shape/mod.rs
new file mode 100644
index 000000000..41cee56e1
--- /dev/null
+++ b/src/core/src/renderable/shape/mod.rs
@@ -0,0 +1,62 @@
+use crate::math::{angle::Angle, lonlat::LonLatT};
+use al_api::color::ColorRGBA;
+use serde::Deserialize;
+
+mod circle;
+mod ellipsis;
+mod image;
+mod polyline;
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Shape {
+    Box {
+        /// Center of the box
+        c: LonLatT<f32>,
+        /// Size following the RA axis
+        ra_w: Angle<f32>,
+        /// Size following the Dec axis
+        dec_h: Angle<f32>,
+        /// Rotation of the box in the RA-Dec space
+        rot: Angle<f32>,
+    },
+    Circle {
+        /// Center of the circle
+        c: LonLatT<f32>,
+        /// Radius of the circle
+        rad: Angle<f32>,
+    },
+    PolyLine(Box<[LonLatT<f32>]>),
+    Ellipsis {
+        /// Center of the ellipsis
+        c: LonLatT<f32>,
+        /// Semi-major axis
+        a: Angle<f32>,
+        /// Semi-minor axis
+        b: Angle<f32>,
+        /// Rotation angle of the ellipsis. Origin aligns the ellipsis' major axis with the north pole. Positive angle points towards the east.
+        rot: Angle<f32>,
+    },
+    // TODO
+    Image,
+}
+
+#[derive(Debug, Deserialize)]
+pub enum Style {
+    None,
+    Dashed,
+    Dotted,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Footprint {
+    shapes: Vec<Shape>,
+    /// Some styling meta data
+    color: ColorRGBA,
+    filled: bool,
+    thickness: f32,
+    style: Style,
+}
+
+type Catalog = Footprint;
diff --git a/src/core/src/renderable/shape/polyline.rs b/src/core/src/renderable/shape/polyline.rs
new file mode 100644
index 000000000..8573d4aba
--- /dev/null
+++ b/src/core/src/renderable/shape/polyline.rs
@@ -0,0 +1,210 @@
+use crate::math::projection::ProjectionType;
+use crate::shader::ShaderManager;
+use al_api::coo_system::CooSystem;
+use al_core::VertexArrayObject;
+use al_core::WebGlContext;
+
+use al_api::color::ColorRGBA;
+
+pub struct PolylineRenderer {
+    gl: WebGlContext,
+    vao: VertexArrayObject,
+
+    color: ColorRGBA,
+    thickness: f32,
+    num_instances: usize,
+}
+use wasm_bindgen::JsValue;
+
+use al_core::VecData;
+use web_sys::WebGl2RenderingContext;
+
+use crate::camera::CameraViewPort;
+
+use super::Shape;
+
+use super::Catalog;
+
+impl PolylineRenderer {
+    /// Init the buffers, VAO and shader
+    pub fn new<'a>(gl: &WebGlContext, catalog: &Catalog) -> Result<Self, JsValue> {
+        let lines = catalog
+            .shapes
+            .iter()
+            .flat_map(|s| {
+                let mut v = vec![];
+                match s {
+                    Shape::PolyLine(vertices) => {
+                        for (v1, v2) in vertices.iter().zip(vertices.iter().skip(1)) {
+                            v.extend_from_slice(&[
+                                v1.lon().to_radians(),
+                                v1.lat().to_radians(),
+                                v2.lon().to_radians(),
+                                v2.lat().to_radians(),
+                            ])
+                        }
+                    }
+                    _ => (),
+                }
+
+                v
+            })
+            .collect::<Vec<_>>();
+
+        let num_instances = lines.len() / 4;
+
+        // Create the VAO for the screen
+        let mut vao = VertexArrayObject::new(&gl);
+        vao.bind_for_update()
+            // Store the cartesian position of the center of the source in the a instanced VBO
+            .add_instanced_array_buffer(
+                "line",
+                9 * std::mem::size_of::<f32>(),
+                &[2, 2],
+                &[0, 2 * std::mem::size_of::<f32>()],
+                WebGl2RenderingContext::STATIC_DRAW,
+                VecData::<f32>(&lines),
+            )
+            .add_array_buffer(
+                "vertices",
+                2 * std::mem::size_of::<f32>(),
+                &[2],
+                &[0],
+                WebGl2RenderingContext::STATIC_DRAW,
+                &[
+                    0_f32, -0.5_f32, 1_f32, -0.5_f32, 1_f32, 0.5_f32, 0_f32, 0.5_f32,
+                ] as &[f32],
+            )
+            // Set the element buffer
+            .add_element_buffer(
+                WebGl2RenderingContext::STATIC_DRAW,
+                &[0_u16, 1_u16, 2_u16, 0_u16, 2_u16, 3_u16] as &[u16],
+            )
+            // Unbind the buffer
+            .unbind();
+
+        let gl = gl.clone();
+
+        Ok(Self {
+            gl,
+            vao,
+            color: catalog.color,
+            thickness: catalog.thickness,
+            num_instances,
+        })
+    }
+
+    /*pub fn add_fill_paths<V>(
+        &mut self,
+        paths: impl Iterator<Item = PathVertices<V>>,
+        color: &ColorRGBA,
+        coo_space: CooSpace,
+    ) where
+        V: AsRef<[[f32; 2]]>,
+    {
+        let mut num_indices = 0;
+        let off_indices = self.indices.len();
+        let mut geometry: VertexBuffers<[f32; 2], u32> = VertexBuffers::new();
+
+        let mut tessellator = FillTessellator::new();
+
+        //let mut num_vertices = 0;
+        for path in paths {
+            let mut path_builder = Path::builder();
+
+            let PathVertices {
+                vertices, /*, closed */
+            } = path;
+
+            let line = vertices.as_ref();
+
+            if !line.is_empty() {
+                let v = &line[0];
+                path_builder.begin(point(v[0], v[1]));
+
+                for v in line.iter().skip(1) {
+                    //let v = clamp_ndc_vertex(v);
+                    path_builder.line_to(point(v[0], v[1]));
+                }
+
+                path_builder.end(false);
+            }
+
+            // Create the destination vertex and index buffers.
+            let p = path_builder.build();
+            // Let's use our own custom vertex type instead of the default one.
+            // Will contain the result of the tessellation.
+            let num_vertices = (self.vertices.len() / 2) as u32;
+
+            // Compute the tessellation.
+            tessellator
+                .tessellate_with_ids(
+                    p.id_iter(),
+                    &p,
+                    Some(&p),
+                    &FillOptions::default()
+                        .with_intersections(false)
+                        .with_fill_rule(FillRule::NonZero)
+                        .with_tolerance(5e-3),
+                    &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex| {
+                        vertex.position().to_array()
+                    })
+                    .with_vertex_offset(num_vertices),
+                )
+                .unwrap_abort();
+        }
+        let VertexBuffers { vertices, indices } = geometry;
+        num_indices += indices.len();
+
+        self.vertices.extend(vertices.iter().flatten());
+        self.indices.extend(indices.iter());
+
+        //al_core::info!("num vertices fill", nv);
+
+        self.meta.push(Meta {
+            off_indices,
+            num_indices,
+            thickness: 1.0,
+            color: color.clone(),
+            coo_space,
+        });
+    }*/
+
+    pub fn draw(
+        &mut self,
+        shaders: &mut ShaderManager,
+        camera: &CameraViewPort,
+        proj: &ProjectionType,
+    ) -> Result<(), JsValue> {
+        self.gl.enable(WebGl2RenderingContext::BLEND);
+        self.gl.blend_func_separate(
+            WebGl2RenderingContext::SRC_ALPHA,
+            WebGl2RenderingContext::ONE_MINUS_SRC_ALPHA,
+            WebGl2RenderingContext::ONE,
+            WebGl2RenderingContext::ONE,
+        );
+
+        // draw the instanced lines
+        let icrs2view = CooSystem::ICRS.to(camera.get_coo_system());
+        let view2world = camera.get_m2w();
+        let icrs2world = view2world * icrs2view;
+
+        crate::shader::get_shader(&self.gl, shaders, "line_inst_lonlat.vert", "line_base.frag")?
+            .bind(&self.gl)
+            .attach_uniforms_from(camera)
+            .attach_uniform("u_2world", &icrs2world)
+            .attach_uniform("u_color", &self.color)
+            .attach_uniform("u_width", &self.thickness)
+            .attach_uniform("u_proj", proj)
+            .bind_vertex_array_object_ref(&self.vao)
+            .draw_elements_instanced_with_i32(
+                WebGl2RenderingContext::TRIANGLES,
+                0,
+                self.num_instances as i32,
+            );
+
+        self.gl.disable(WebGl2RenderingContext::BLEND);
+
+        Ok(())
+    }
+}
diff --git a/src/js/Aladin.js b/src/js/Aladin.js
index b9053b627..6edb986e1 100644
--- a/src/js/Aladin.js
+++ b/src/js/Aladin.js
@@ -1428,9 +1428,11 @@ export let Aladin = (function () {
     Aladin.prototype.showSurvey = function (show) {
         this.view.showSurvey(show);
     };
+
     Aladin.prototype.showCatalog = function (show) {
         this.view.showCatalog(show);
     };
+
     Aladin.prototype.showReticle = function (show) {
         this.reticle.update({ show });
     };
diff --git a/src/js/View.js b/src/js/View.js
index 366208f1d..09b5a4110 100644
--- a/src/js/View.js
+++ b/src/js/View.js
@@ -48,6 +48,8 @@ import { DefaultActionsForContextMenu } from "./DefaultActionsForContextMenu.js"
 import { Layout } from "./gui/Layout.js";
 import { SAMPActionButton } from "./gui/Button/SAMP.js";
 import { HiPSCache } from "./DefaultHiPSCache.js";
+import { ImageHiPS } from "./ImageHiPS.js";
+import { ImageFITS } from "./ImageFITS.js";
 
 export let View = (function () {