@tishlang/tish 1.0.29 → 1.0.33

package/crates/tish_ui/src/runtime/hooks.rs

@@ -0,0 +1,122 @@
+//! Minimal hook state: `useState` + render flush (Lattish-style cursor reset).
+
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+use tishlang_core::{ObjectMap, Value};
+
+use super::ACTIVE_HOST;
+
+thread_local! {
+    pub static HOOK: RefCell<HookState> = RefCell::new(HookState::default());
+    static IN_FLUSH: Cell<bool> = Cell::new(false);
+}
+
+#[derive(Default)]
+pub struct HookState {
+    pub state_slots: Rc<RefCell<Vec<Value>>>,
+    pub cursor: usize,
+    pub root_app: Option<Value>,
+    pub root_vnode: Option<Value>,
+    pub flush_scheduled: bool,
+}
+
+impl HookState {
+    pub fn reset_for_new_root(&mut self) {
+        self.state_slots.borrow_mut().clear();
+        self.cursor = 0;
+        self.root_vnode = None;
+        self.flush_scheduled = false;
+    }
+}
+
+/// `useState(initial)` → `[state, setState]` as a Tish array.
+pub fn native_use_state(args: &[Value]) -> Value {
+    let initial = args.first().cloned().unwrap_or(Value::Null);
+    HOOK.with(|h| {
+        let mut st = h.borrow_mut();
+        let i = st.cursor;
+        st.cursor += 1;
+        let slots = Rc::clone(&st.state_slots);
+        while i >= slots.borrow().len() {
+            slots.borrow_mut().push(initial.clone());
+        }
+        let current = slots.borrow()[i].clone();
+        let idx = i;
+        let setter = Value::Function(Rc::new(move |a: &[Value]| {
+            let new_v = a.first().cloned().unwrap_or(Value::Null);
+            slots.borrow_mut()[idx] = new_v;
+            schedule_flush();
+            Value::Null
+        }));
+        Value::Array(Rc::new(RefCell::new(vec![current, setter])))
+    })
+}
+
+/// `createRoot(container)` → `{ render: (App) => { ... } }` (container ignored for headless native).
+pub fn native_create_root(args: &[Value]) -> Value {
+    let _container = args.first();
+    let render_fn = Value::Function(Rc::new(|app_args: &[Value]| {
+        let app = app_args.first().cloned().unwrap_or(Value::Null);
+        HOOK.with(|h| {
+            let mut st = h.borrow_mut();
+            st.reset_for_new_root();
+            st.root_app = Some(app);
+            st.flush_scheduled = true;
+        });
+        drain_flush_queue();
+        Value::Null
+    }));
+    Value::Object(Rc::new(RefCell::new(ObjectMap::from([(
+        std::sync::Arc::from("render"),
+        render_fn,
+    )]))))
+}
+
+/// Request a re-render (coalesced; safe if called during flush).
+pub fn schedule_flush() {
+    HOOK.with(|h| {
+        h.borrow_mut().flush_scheduled = true;
+    });
+    if IN_FLUSH.get() {
+        return;
+    }
+    drain_flush_queue();
+}
+
+fn drain_flush_queue() {
+    loop {
+        let run = HOOK.with(|h| {
+            let mut st = h.borrow_mut();
+            if st.flush_scheduled {
+                st.flush_scheduled = false;
+                true
+            } else {
+                false
+            }
+        });
+        if !run {
+            break;
+        }
+        IN_FLUSH.set(true);
+        HOOK.with(|h| {
+            let mut st = h.borrow_mut();
+            st.cursor = 0;
+            let Some(app) = st.root_app.clone() else {
+                return;
+            };
+            let Value::Function(f) = app else {
+                return;
+            };
+            let tree = f(&[]);
+            st.root_vnode = Some(tree.clone());
+            ACTIVE_HOST.with(|host_cell| {
+                let mut host_opt = host_cell.borrow_mut();
+                if let Some(host) = host_opt.as_deref_mut() {
+                    host.commit_root(&tree);
+                }
+            });
+        });
+        IN_FLUSH.set(false);
+    }
+}

package/crates/tish_ui/src/runtime/mod.rs

@@ -0,0 +1,173 @@
+//! UI runtime: `h`, `Fragment`, vnode shapes compatible with Lattish, minimal hooks, and [`Host`].
+
+mod hooks;
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+pub use hooks::{native_create_root, native_use_state, schedule_flush, HookState, HOOK};
+
+use tishlang_core::{ObjectMap, Value};
+
+/// Sentinel string for `Fragment` (native). JS/Lattish uses `Symbol`; hosts compare via equality.
+pub const FRAGMENT_SENTINEL: &str = "__tish_ui_Fragment__";
+
+/// `Fragment` marker value for `h(Fragment, null, children)`.
+pub fn fragment_value() -> Value {
+    Value::String(FRAGMENT_SENTINEL.into())
+}
+
+/// Returns true if `tag` refers to [`fragment_value`].
+pub fn is_fragment_tag(tag: &Value) -> bool {
+    matches!(tag, Value::String(s) if s.as_ref() == FRAGMENT_SENTINEL)
+}
+
+/// `text(s)` helper — returns string as `Value::String` for JSX text nodes.
+pub fn ui_text(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(|v| v.to_display_string())
+        .unwrap_or_default();
+    Value::String(s.into())
+}
+
+/// Vnode factory: `h(tag, props, children)` (Lattish-compatible shape).
+pub fn ui_h(args: &[Value]) -> Value {
+    let tag = args.get(0).cloned().unwrap_or(Value::Null);
+    let props = args.get(1).cloned().unwrap_or(Value::Null);
+    let children_arg = args.get(2).cloned().unwrap_or(Value::Null);
+
+    let children_vec = normalize_children_list(children_arg);
+
+    if let Value::Function(f) = &tag {
+        let mut merged = if matches!(props, Value::Null) {
+            ObjectMap::default()
+        } else if let Value::Object(obj) = props {
+            obj.borrow().clone()
+        } else {
+            ObjectMap::default()
+        };
+        if !children_vec.is_empty() {
+            merged.insert(
+                Arc::from("children"),
+                Value::Array(Rc::new(RefCell::new(children_vec.clone()))),
+            );
+        }
+        return f(&[Value::Object(Rc::new(RefCell::new(merged)))]);
+    }
+
+    if is_fragment_tag(&tag) {
+        return vnode_fragment(children_vec);
+    }
+
+    let tag_str: Arc<str> = match tag {
+        Value::String(s) => s,
+        _ => return Value::Null,
+    };
+
+    vnode_element(tag_str, props, children_vec)
+}
+
+fn normalize_children_list(children_arg: Value) -> Vec<Value> {
+    match children_arg {
+        Value::Null => vec![],
+        Value::Array(a) => a.borrow().clone(),
+        other => vec![other],
+    }
+}
+
+fn vnode_element(tag: Arc<str>, props: Value, children: Vec<Value>) -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("tag"), Value::String(tag));
+    m.insert(
+        Arc::from("props"),
+        if matches!(props, Value::Null) {
+            Value::Null
+        } else {
+            props
+        },
+    );
+    m.insert(
+        Arc::from("children"),
+        Value::Array(Rc::new(RefCell::new(children))),
+    );
+    m.insert(Arc::from("_el"), Value::Null);
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn vnode_fragment(children: Vec<Value>) -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("tag"), fragment_value());
+    m.insert(Arc::from("props"), Value::Null);
+    m.insert(
+        Arc::from("children"),
+        Value::Array(Rc::new(RefCell::new(children))),
+    );
+    m.insert(Arc::from("_el"), Value::Null);
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+/// Pluggable UI backend (Floem, DOM, SwiftUI, …). Main-thread / single-threaded by default.
+pub trait Host {
+    /// Apply a new root vnode (after each render flush).
+    fn commit_root(&mut self, vnode: &Value);
+}
+
+/// No-op / test host that only stores the last committed tree.
+pub struct HeadlessHost {
+    pub last: Option<Value>,
+}
+
+impl Default for HeadlessHost {
+    fn default() -> Self {
+        Self { last: None }
+    }
+}
+
+impl Host for HeadlessHost {
+    fn commit_root(&mut self, vnode: &Value) {
+        self.last = Some(vnode.clone());
+    }
+}
+
+thread_local! {
+    static ACTIVE_HOST: RefCell<Option<Box<dyn Host>>> = RefCell::new(None);
+}
+
+/// Install the thread-local host used by [`schedule_flush`] / `createRoot`.
+pub fn install_thread_local_host(host: Box<dyn Host>) {
+    ACTIVE_HOST.with(|c| {
+        *c.borrow_mut() = Some(host);
+    });
+}
+
+pub fn with_thread_local_host<R>(f: impl FnOnce(&mut dyn Host) -> R) -> Option<R> {
+    ACTIVE_HOST.with(|c| {
+        let mut opt = c.borrow_mut();
+        match opt.as_deref_mut() {
+            Some(host) => Some(f(host)),
+            None => None,
+        }
+    })
+}
+
+/// Tag registry hook for future host-specific intrinsic mapping (HTML tag → component kind).
+#[derive(Default)]
+pub struct TagRegistry;
+
+impl TagRegistry {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+/// Placeholder for subset CSS / style object interpretation.
+#[derive(Default)]
+pub struct StyleInterpreter;
+
+impl StyleInterpreter {
+    pub fn new() -> Self {
+        Self
+    }
+}

package/crates/tish_vm/src/vm.rs

@@ -1,17 +1,17 @@
 //! Stack-based bytecode VM.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
 use tishlang_ast::{BinOp, UnaryOp};
 use tishlang_builtins::array as arr_builtins;
+use tishlang_builtins::construct as construct_builtin;
 use tishlang_builtins::string as str_builtins;
 use tishlang_builtins::globals as globals_builtins;
 use tishlang_builtins::math as math_builtins;
 use tishlang_bytecode::{u8_to_binop, u8_to_unaryop, Chunk, Constant, Opcode, NO_REST_PARAM};
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 
 type ArrayMethodFn = Rc<dyn Fn(&[Value]) -> Value>;
 
@@ -69,7 +69,7 @@ fn get_builtin_export(spec: &str, export_name: &str) -> Option<Value> {
                     .collect(),
             )))),
             "process" => {
-                let mut m = HashMap::new();
+                let mut m = ObjectMap::default();
                 m.insert("exit".into(), Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::process_exit(args))));
                 m.insert("cwd".into(), Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::process_cwd(args))));
                 m.insert("exec".into(), Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::process_exec(args))));
@@ -145,10 +145,10 @@ fn vm_log_err(s: &str) {
 }
 
 /// Initialize default globals (console, Math, JSON, etc.)
-fn init_globals() -> HashMap<Arc<str>, Value> {
-    let mut g = HashMap::new();
+fn init_globals() -> ObjectMap {
+    let mut g = ObjectMap::default();
 
-    let mut console = HashMap::new();
+    let mut console = ObjectMap::default();
     console.insert(
         "debug".into(),
         Value::Function(Rc::new(|args: &[Value]| {
@@ -191,7 +191,7 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
     );
     g.insert("console".into(), Value::Object(Rc::new(RefCell::new(console))));
 
-    let mut math = HashMap::new();
+    let mut math = ObjectMap::default();
     math.insert(
         "abs".into(),
         Value::Function(Rc::new(|args: &[Value]| {
@@ -257,7 +257,7 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
     math.insert("E".into(), Value::Number(std::f64::consts::E));
     g.insert("Math".into(), Value::Object(Rc::new(RefCell::new(math))));
 
-    let mut json = HashMap::new();
+    let mut json = ObjectMap::default();
     json.insert(
         "parse".into(),
         Value::Function(Rc::new(|args: &[Value]| {
@@ -292,7 +292,7 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
     );
 
     // Date - at minimum Date.now() for timing
-    let mut date = HashMap::new();
+    let mut date = ObjectMap::default();
     date.insert(
         "now".into(),
         Value::Function(Rc::new(|_args: &[Value]| {
@@ -305,8 +305,17 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
     );
     g.insert("Date".into(), Value::Object(Rc::new(RefCell::new(date))));
 
+    g.insert(
+        "Uint8Array".into(),
+        construct_builtin::uint8_array_constructor_value(),
+    );
+    g.insert(
+        "AudioContext".into(),
+        construct_builtin::audio_context_constructor_value(),
+    );
+
     // Object methods - delegate to tishlang_builtins::globals
-    let mut object_methods = HashMap::new();
+    let mut object_methods = ObjectMap::default();
     object_methods.insert(
         "assign".into(),
         Value::Function(Rc::new(|args: &[Value]| globals_builtins::object_assign(args))),
@@ -321,7 +330,7 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
     g.insert("Object".into(), Value::Object(Rc::new(RefCell::new(object_methods))));
 
     // Array.isArray
-    let mut array_static = HashMap::new();
+    let mut array_static = ObjectMap::default();
     array_static.insert(
         "isArray".into(),
         Value::Function(Rc::new(|args: &[Value]| globals_builtins::array_is_array(args))),
@@ -330,7 +339,7 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
 
     // String(value) as callable + String.fromCharCode
     let string_convert_fn = Value::Function(Rc::new(|args: &[Value]| globals_builtins::string_convert(args)));
-    let mut string_static = HashMap::new();
+    let mut string_static = ObjectMap::default();
     string_static.insert("fromCharCode".into(), Value::Function(Rc::new(|args: &[Value]| globals_builtins::string_from_char_code(args))));
     string_static.insert(Arc::from("__call"), string_convert_fn);
     g.insert("String".into(), Value::Object(Rc::new(RefCell::new(string_static))));
@@ -342,12 +351,12 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
     );
     g.insert(
         "Fragment".into(),
-        Value::Object(Rc::new(RefCell::new(HashMap::new()))),
+        Value::Object(Rc::new(RefCell::new(ObjectMap::default()))),
     );
     g.insert(
         "createRoot".into(),
         Value::Function(Rc::new(|_args: &[Value]| {
-            let mut render_obj = HashMap::new();
+            let mut render_obj = ObjectMap::default();
             render_obj.insert(
                 "render".into(),
                 Value::Function(Rc::new(|_args: &[Value]| Value::Null)),
@@ -363,13 +372,13 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
             Value::Array(Rc::new(RefCell::new(arr)))
         })),
     );
-    let mut document_obj = HashMap::new();
+    let mut document_obj = ObjectMap::default();
     document_obj.insert("body".into(), Value::Null);
     g.insert("document".into(), Value::Object(Rc::new(RefCell::new(document_obj))));
 
     #[cfg(feature = "process")]
     {
-        let mut process_obj = HashMap::new();
+        let mut process_obj = ObjectMap::default();
         process_obj.insert(
             "exit".into(),
             Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::process_exit(args))),
@@ -418,21 +427,21 @@ fn init_globals() -> HashMap<Arc<str>, Value> {
 }
 
 /// Shared scope for closure capture (parent frame's locals).
-type ScopeMap = Rc<RefCell<HashMap<Arc<str>, Value>>>;
+type ScopeMap = Rc<RefCell<ObjectMap>>;
 
 pub struct Vm {
     stack: Vec<Value>,
-    scope: HashMap<Arc<str>, Value>,
+    scope: ObjectMap,
     /// Enclosing scope for closures (captured parent frame locals).
     enclosing: Option<ScopeMap>,
-    globals: Rc<RefCell<HashMap<Arc<str>, Value>>>,
+    globals: Rc<RefCell<ObjectMap>>,
 }
 
 impl Vm {
     pub fn new() -> Self {
         Self {
             stack: Vec::new(),
-            scope: HashMap::new(),
+            scope: ObjectMap::default(),
             enclosing: None,
             globals: Rc::new(RefCell::new(init_globals())),
         }
@@ -477,7 +486,7 @@ impl Vm {
         let names = &chunk.names;
 
         let mut ip = 0;
-        let local_scope: ScopeMap = Rc::new(RefCell::new(HashMap::new()));
+        let local_scope: ScopeMap = Rc::new(RefCell::new(ObjectMap::default()));
         {
             let mut ls = local_scope.borrow_mut();
             let param_count = chunk.param_count as usize;
@@ -538,7 +547,7 @@ impl Vm {
                             Value::Function(Rc::new(move |args: &[Value]| {
                                 let mut vm = Vm {
                                     stack: Vec::new(),
-                                    scope: HashMap::new(),
+                                    scope: ObjectMap::default(),
                                     enclosing: enclosing.clone(),
                                     globals: Rc::clone(&globals),
                                 };
@@ -723,6 +732,45 @@ impl Vm {
                     let result = f(&args);
                     self.stack.push(result);
                 }
+                Opcode::Construct => {
+                    let argc = Self::read_u16(code, &mut ip) as usize;
+                    let mut args = Vec::with_capacity(argc);
+                    for _ in 0..argc {
+                        args.push(
+                            self.stack
+                                .pop()
+                                .ok_or_else(|| "Stack underflow in construct".to_string())?,
+                        );
+                    }
+                    args.reverse();
+                    let callee = self
+                        .stack
+                        .pop()
+                        .ok_or_else(|| "Stack underflow: no callee for construct".to_string())?;
+                    let result = construct_builtin::construct(&callee, &args);
+                    self.stack.push(result);
+                }
+                Opcode::ConstructSpread => {
+                    let callee = self
+                        .stack
+                        .pop()
+                        .ok_or_else(|| "Stack underflow: callee in ConstructSpread".to_string())?;
+                    let args_array = self
+                        .stack
+                        .pop()
+                        .ok_or_else(|| "Stack underflow in ConstructSpread".to_string())?;
+                    let args: Vec<Value> = match &args_array {
+                        Value::Array(a) => a.borrow().clone(),
+                        _ => {
+                            return Err(format!(
+                                "ConstructSpread: args must be array, got {}",
+                                args_array.to_display_string()
+                            ));
+                        }
+                    };
+                    let result = construct_builtin::construct(&callee, &args);
+                    self.stack.push(result);
+                }
                 Opcode::Return => {
                     let v = self.stack.pop().unwrap_or(Value::Null);
                     return Ok(v);
@@ -861,7 +909,7 @@ impl Vm {
                 }
                 Opcode::NewObject => {
                     let n = Self::read_u16(code, &mut ip) as usize;
-                    let mut map = HashMap::new();
+                    let mut map = ObjectMap::with_capacity(n.max(1));
                     for _ in 0..n {
                         let val = self
                             .stack
@@ -926,7 +974,11 @@ impl Vm {
                         .stack
                         .pop()
                         .ok_or_else(|| "Stack underflow".to_string())?;
-                    let mut merged: HashMap<Arc<str>, Value> = HashMap::new();
+                    let cap = match (&left, &right) {
+                        (Value::Object(l), Value::Object(r)) => l.borrow().len() + r.borrow().len(),
+                        _ => 0,
+                    };
+                    let mut merged: ObjectMap = ObjectMap::with_capacity(cap.max(8));
                     if let Value::Object(l) = &left {
                         merged.extend(l.borrow().iter().map(|(k, v)| (Arc::clone(k), v.clone())));
                     } else {
@@ -1112,6 +1164,40 @@ impl Default for Vm {
     }
 }
 
+/// Rough byte capacity for string coercion (matches hot paths like `"x" + n + "ms"`).
+fn estimate_string_concat_len(v: &Value) -> usize {
+    match v {
+        Value::String(s) => s.len(),
+        Value::Number(_) => 24,
+        Value::Bool(_) => 5,
+        Value::Null => 4,
+        _ => 32,
+    }
+}
+
+/// Append JS-style string conversion without an intermediate `String` per operand (unlike
+/// `format!("{}{}", a.to_display_string(), b.to_display_string())`, which triple-allocates).
+fn append_value_for_string_concat(out: &mut String, v: &Value) {
+    use std::fmt::Write;
+    match v {
+        Value::Number(n) => {
+            if n.is_nan() {
+                out.push_str("NaN");
+            } else if *n == f64::INFINITY {
+                out.push_str("Infinity");
+            } else if *n == f64::NEG_INFINITY {
+                out.push_str("-Infinity");
+            } else {
+                let _ = write!(out, "{n}");
+            }
+        }
+        Value::String(s) => out.push_str(s.as_ref()),
+        Value::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
+        Value::Null => out.push_str("null"),
+        _ => out.push_str(&v.to_display_string()),
+    }
+}
+
 fn eval_binop(op: BinOp, l: &Value, r: &Value) -> Result<Value, String> {
     use tishlang_ast::BinOp::*;
     use tishlang_core::Value::*;
@@ -1120,7 +1206,11 @@ fn eval_binop(op: BinOp, l: &Value, r: &Value) -> Result<Value, String> {
     match op {
         Add => {
             if matches!(l, Value::String(_)) || matches!(r, Value::String(_)) {
-                Ok(String(format!("{}{}", l.to_display_string(), r.to_display_string()).into()))
+                let cap = estimate_string_concat_len(l) + estimate_string_concat_len(r);
+                let mut buf = std::string::String::with_capacity(cap);
+                append_value_for_string_concat(&mut buf, l);
+                append_value_for_string_concat(&mut buf, r);
+                Ok(String(buf.into()))
             } else {
                 Ok(Number(ln + rn))
             }
@@ -1146,9 +1236,13 @@ fn eval_binop(op: BinOp, l: &Value, r: &Value) -> Result<Value, String> {
         Shl => Ok(Number(((ln as i32) << (rn as i32)) as f64)),
         Shr => Ok(Number(((ln as i32) >> (rn as i32)) as f64)),
         In => {
-            let key_s: Arc<str> = l.to_display_string().into();
+            let key_s: Arc<str> = match l {
+                Value::String(s) => Arc::clone(s),
+                Value::Number(n) => n.to_string().into(),
+                _ => l.to_display_string().into(),
+            };
             Ok(Bool(match r {
-                Value::Object(m) => m.borrow().contains_key(&key_s),
+                Value::Object(m) => m.borrow().contains_key(key_s.as_ref()),
                 Value::Array(a) => {
                     if key_s.as_ref() == "length" {
                         true

package/justfile

@@ -125,15 +125,15 @@ test *ARGS:
 
 # Run only tish package tests (same as CI: integration tests only)
 test-tish *ARGS:
-    cargo nextest run -p tish --features full -- {{ARGS}}
+    cargo nextest run -p tishlang--features full -- {{ARGS}}
 
 # Skip slow backend tests (native/cranelift/wasi) for fast local iteration
 test-quick:
-    cargo nextest run -p tish --features full -- --skip test_mvp_programs_native --skip test_mvp_programs_cranelift --skip test_mvp_programs_wasi
+    cargo nextest run -p tishlang--features full -- --skip test_mvp_programs_native --skip test_mvp_programs_cranelift --skip test_mvp_programs_wasi
 
 # Run tests with coverage (requires llvm-tools: rustup component add llvm-tools-preview)
 test-coverage:
-    cargo llvm-cov nextest -p tish --features full --lcov --output-path lcov.info --html coverage-html
+    cargo llvm-cov nextest -p tishlang--features full --lcov --output-path lcov.info --html coverage-html
 
 # Plain cargo test (whole workspace)
 test-cargo:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.0.29",
+  "version": "1.0.33",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, compile to native.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {