openzoo 0.51.4 → 0.51.6

package/transmute/runtime/zoo-host/src/fmt.rs

@@ -1,188 +0,0 @@
-//! Number and hex formatting without `core::fmt`: the float/integer printers
-//! behind `format!` cost ~50 KB of program (flt2dec dragon/grisu + Formatter),
-//! which at Solana rent rates is a third of a SOL per site. These are the
-//! handful of shapes the runtime actually needs.
-use alloc::string::String;
-
-pub fn push_u64(out: &mut String, mut n: u64) {
-    if n == 0 {
-        out.push('0');
-        return;
-    }
-    let mut buf = [0u8; 20];
-    let mut i = buf.len();
-    while n > 0 {
-        i -= 1;
-        buf[i] = b'0' + (n % 10) as u8;
-        n /= 10;
-    }
-    for &b in &buf[i..] {
-        out.push(b as char);
-    }
-}
-
-pub fn push_i64(out: &mut String, n: i64) {
-    if n < 0 {
-        out.push('-');
-        push_u64(out, n.unsigned_abs());
-    } else {
-        push_u64(out, n as u64);
-    }
-}
-
-/// Zero-padded decimal (for dates: `2026`, `09`, `007`).
-pub fn push_padded(out: &mut String, n: u64, width: usize) {
-    let mut tmp = String::new();
-    push_u64(&mut tmp, n);
-    for _ in tmp.len()..width {
-        out.push('0');
-    }
-    out.push_str(&tmp);
-}
-
-pub fn push_hex2(out: &mut String, b: u8) {
-    const H: &[u8; 16] = b"0123456789ABCDEF";
-    out.push(H[(b >> 4) as usize] as char);
-    out.push(H[(b & 15) as usize] as char);
-}
-
-pub fn u64_string(n: u64) -> String {
-    let mut s = String::new();
-    push_u64(&mut s, n);
-    s
-}
-
-/// 10^k for small k without `libm::pow`.
-pub fn pow10(k: u32) -> f64 {
-    let mut v = 1.0;
-    for _ in 0..k {
-        v *= 10.0;
-    }
-    v
-}
-
-/// JS `Number.prototype.toString()` for the common cases, hand-rolled:
-/// integers exactly (|n| < 1e21), otherwise up to 15 significant digits with
-/// trailing zeros trimmed (`0.1 + 0.2` prints `0.30000000000000004` in JS and
-/// `0.3` here — the one visible difference), exponent form outside
-/// [1e-6, 1e21) like JS.
-pub fn push_f64(out: &mut String, n: f64) {
-    if n.is_nan() {
-        out.push_str("NaN");
-        return;
-    }
-    if n.is_infinite() {
-        out.push_str(if n > 0.0 { "Infinity" } else { "-Infinity" });
-        return;
-    }
-    if n == 0.0 {
-        out.push('0');
-        return;
-    }
-    let neg = n < 0.0;
-    let a = if neg { -n } else { n };
-    if neg {
-        out.push('-');
-    }
-    if a == libm::trunc(a) && a < 9.0e18 {
-        push_u64(out, a as u64);
-        return;
-    }
-    // Scientific decomposition: a = m × 10^e with 1 <= m < 10.
-    let mut e: i32 = 0;
-    let mut m = a;
-    while m >= 10.0 {
-        m /= 10.0;
-        e += 1;
-    }
-    while m < 1.0 {
-        m *= 10.0;
-        e -= 1;
-    }
-    // 15 significant digits, rounded.
-    let mut digits = [0u8; 17];
-    let mut nd = 0;
-    let mut scaled = m * 1e14; // 15 digits before the point
-    scaled = libm::round(scaled);
-    if scaled >= 1e15 {
-        scaled /= 10.0;
-        e += 1;
-    }
-    let mut v = scaled as u64;
-    let mut tmp = [0u8; 20];
-    let mut i = tmp.len();
-    while v > 0 {
-        i -= 1;
-        tmp[i] = (v % 10) as u8;
-        v /= 10;
-    }
-    for &d in &tmp[i..] {
-        digits[nd] = d;
-        nd += 1;
-    }
-    while nd > 1 && digits[nd - 1] == 0 {
-        nd -= 1;
-    }
-    if !(-7..21).contains(&e) {
-        out.push((b'0' + digits[0]) as char);
-        if nd > 1 {
-            out.push('.');
-            for &d in &digits[1..nd] {
-                out.push((b'0' + d) as char);
-            }
-        }
-        out.push('e');
-        out.push(if e < 0 { '-' } else { '+' });
-        push_u64(out, e.unsigned_abs() as u64);
-        return;
-    }
-    if e < 0 {
-        out.push_str("0.");
-        for _ in 0..(-e - 1) {
-            out.push('0');
-        }
-        for &d in &digits[..nd] {
-            out.push((b'0' + d) as char);
-        }
-        return;
-    }
-    let int_len = (e + 1) as usize;
-    for k in 0..int_len {
-        out.push((b'0' + if k < nd { digits[k] } else { 0 }) as char);
-    }
-    if nd > int_len {
-        out.push('.');
-        for &d in &digits[int_len..nd] {
-            out.push((b'0' + d) as char);
-        }
-    }
-}
-
-/// `toFixed(digits)`.
-pub fn to_fixed(n: f64, digits: usize) -> String {
-    let mut out = String::new();
-    if n.is_nan() {
-        out.push_str("NaN");
-        return out;
-    }
-    let neg = n < 0.0;
-    let a = if neg { -n } else { n };
-    let m = pow10(digits as u32);
-    let scaled = libm::round(a * m) as u64;
-    let int = scaled / (m as u64);
-    let frac = scaled % (m as u64);
-    if neg && scaled != 0 {
-        out.push('-');
-    }
-    push_u64(&mut out, int);
-    if digits > 0 {
-        out.push('.');
-        let mut f = String::new();
-        push_u64(&mut f, frac);
-        for _ in f.len()..digits {
-            out.push('0');
-        }
-        out.push_str(&f);
-    }
-    out
-}

package/transmute/runtime/zoo-host/src/helpers.rs

@@ -1,245 +0,0 @@
-//! Bridge helpers shared by compiled sites (the generated prelude calls
-//! these) and the bytecode interpreter (by id).
-use crate::json;
-use crate::val::{url_decode, Val};
-use crate::Ctx;
-use alloc::{string::String, vec::Vec};
-
-/// Response value for app-router handlers: a tagged object `send` turns into
-/// the bridge response.
-pub fn resp(kind: &str, a: Val, b: Val) -> Val {
-    let mut o = Val::obj();
-    o.set_str("__zoo", Val::str(kind));
-    o.set_str("a", a);
-    o.set_str("b", b);
-    o
-}
-
-pub fn send(cx: &mut Ctx, v: &Val) -> Result<(), Val> {
-    let kind = v.get_str("__zoo");
-    match kind.as_str() {
-        Some("json") => { let a = v.get_str("a"); let b = v.get_str("b"); cx.respond_json(&a, &b); Ok(()) }
-        Some("raw") => { let a = v.get_str("a"); let b = v.get_str("b"); cx.respond(&a, &b); Ok(()) }
-        Some("redirect") => {
-            let url = v.get_str("a");
-            let mut st = v.get_str("b");
-            if let Val::Obj(_) = st { st = st.get_str("status"); }
-            cx.respond_redirect(&url, &st);
-            Ok(())
-        }
-        _ => if v.is_undef() { Ok(()) } else { Err(Val::str("TypeError: the handler returned a value that is not a Response")) },
-    }
-}
-
-/// Runtime throws are strings ("SyntaxError: ..."); in a catch they become
-/// Error-like objects so `e.message` / `e.name` read as in Node.
-pub fn caught(v: Val) -> Val {
-    if let Val::Str(s) = &v {
-        if let Some(i) = s.find(": ") {
-            let name = &s[..i];
-            if name.ends_with("Error") && !name.contains(' ') {
-                let mut o = Val::obj();
-                o.set_str("name", Val::str(name));
-                o.set_str("message", Val::str(&s[i + 2..]));
-                return o;
-            }
-        }
-    }
-    v
-}
-
-pub fn param_value(s: &str, catch_all: bool) -> Val {
-    if catch_all {
-        Val::Arr(s.split('/').filter(|p| !p.is_empty()).map(|p| Val::Str(url_decode(p))).collect())
-    } else {
-        Val::Str(url_decode(s))
-    }
-}
-
-/// A dynamic segment, passed by the gateway as the `x-zoo-param-<name>` header.
-pub fn param(cx: &mut Ctx, name: &str, catch_all: bool) -> Val {
-    let mut h = String::from("x-zoo-param-");
-    h.push_str(name);
-    match cx.req_header(&Val::Str(h)) {
-        Val::Str(s) => param_value(&s, catch_all),
-        _ => Val::Undef,
-    }
-}
-
-pub fn params(cx: &mut Ctx, params: &[(&str, bool)]) -> Val {
-    let mut o = Val::obj();
-    for (name, catch_all) in params.iter() {
-        let v = param(cx, name, *catch_all);
-        if !v.is_undef() { o.set_str(name, v); }
-    }
-    o
-}
-
-/// `req.query`: the query string plus the route's dynamic segments.
-pub fn query(cx: &mut Ctx, params: &[(&str, bool)]) -> Val {
-    let mut q = cx.req_query();
-    for (name, catch_all) in params.iter() {
-        let v = param(cx, name, *catch_all);
-        if !v.is_undef() { q.set_str(name, v); }
-    }
-    q
-}
-
-pub fn cookies(cx: &mut Ctx) -> Val {
-    let mut o = Val::obj();
-    if let Val::Str(h) = cx.req_header(&Val::str("cookie")) {
-        for part in h.split(';') {
-            let p = part.trim();
-            if let Some(i) = p.find('=') { o.set_str(&p[..i], Val::Str(url_decode(&p[i + 1..]))); }
-        }
-    }
-    o
-}
-
-pub fn log(a: &[Val]) -> Val {
-    let mut s = String::new();
-    for (i, v) in a.iter().enumerate() {
-        if i > 0 { s.push(' '); }
-        match v {
-            Val::Str(x) => s.push_str(x),
-            Val::Obj(_) | Val::Arr(_) => s.push_str(&json::stringify(v)),
-            other => s.push_str(&other.to_js_string()),
-        }
-    }
-    crate::wire::log_str(&s);
-    Val::Undef
-}
-
-/// Helper ids shared with the bytecode emitter (lib/compile/bytecode.js).
-pub const H_COOKIES: u8 = 0;
-pub const H_COOKIE_GET: u8 = 1;
-pub const H_COOKIE_HAS: u8 = 2;
-pub const H_COOKIE_ALL: u8 = 3;
-pub const H_HEADER_HAS: u8 = 4;
-pub const H_QUERY_HAS: u8 = 5;
-pub const H_QUERY_GET_ALL: u8 = 6;
-pub const H_SEARCH: u8 = 7;
-pub const H_ASSIGN: u8 = 8;
-pub const H_OMIT: u8 = 9;
-pub const H_FROM_ENTRIES: u8 = 10;
-pub const H_ARRAY_FROM: u8 = 11;
-pub const H_SLICE_FROM: u8 = 12;
-pub const H_URL: u8 = 13;
-pub const H_NUM: u8 = 14;
-pub const H_SET_HEADERS: u8 = 15;
-
-pub fn helper_id(name: &str) -> Option<u8> {
-    Some(match name {
-        "cookies" => H_COOKIES, "cookie_get" => H_COOKIE_GET, "cookie_has" => H_COOKIE_HAS, "cookie_all" => H_COOKIE_ALL,
-        "header_has" => H_HEADER_HAS, "query_has" => H_QUERY_HAS, "query_get_all" => H_QUERY_GET_ALL, "search" => H_SEARCH,
-        "assign" => H_ASSIGN, "omit" => H_OMIT, "from_entries" => H_FROM_ENTRIES, "array_from" => H_ARRAY_FROM,
-        "slice_from" => H_SLICE_FROM, "url" => H_URL, "num" => H_NUM, "set_headers" => H_SET_HEADERS,
-        _ => return None,
-    })
-}
-
-pub fn helper(cx: &mut Ctx, id: u8, a: &[Val]) -> Val {
-    let arg = |i: usize| a.get(i).cloned().unwrap_or(Val::Undef);
-    match id {
-        H_COOKIES => cookies(cx),
-        H_COOKIE_GET => {
-            let name = arg(0);
-            let v = cookies(cx).get(&name);
-            if v.is_undef() { return Val::Undef; }
-            let mut o = Val::obj();
-            o.set_str("name", name);
-            o.set_str("value", v);
-            o
-        }
-        H_COOKIE_HAS => Val::Bool(cookies(cx).has(&arg(0))),
-        H_COOKIE_ALL => {
-            let mut out = Val::arr();
-            if let Val::Obj(kv) = cookies(cx) {
-                for (k, v) in kv {
-                    let mut o = Val::obj();
-                    o.set_str("name", Val::Str(k));
-                    o.set_str("value", v);
-                    out.push(o);
-                }
-            }
-            out
-        }
-        H_HEADER_HAS => Val::Bool(!cx.req_header(&arg(0)).is_nullish()),
-        H_QUERY_HAS => Val::Bool(cx.req_query().has(&arg(0))),
-        H_QUERY_GET_ALL => match cx.req_query_get(&arg(0)) {
-            Val::Null | Val::Undef => Val::arr(),
-            v => Val::Arr(alloc::vec![v]),
-        },
-        H_SEARCH => {
-            let with_q = arg(0).truthy();
-            let u = cx.req_url().to_js_string();
-            match u.find('?') {
-                Some(i) => Val::Str(String::from(if with_q { &u[i..] } else { &u[i + 1..] })),
-                None => Val::str(""),
-            }
-        }
-        H_ASSIGN => {
-            let mut t = if a.is_empty() { Val::obj() } else { arg(0) };
-            for src in a.iter().skip(1) {
-                if let Val::Obj(kv) = src { for (k, v) in kv.iter() { t.set_str(k, v.clone()); } }
-            }
-            t
-        }
-        H_OMIT => {
-            let mut out = Val::obj();
-            let skip: Vec<String> = arg(1).iter_values().iter().map(|k| k.to_js_string()).collect();
-            if let Val::Obj(kv) = arg(0) {
-                for (k, v) in kv.iter() { if !skip.iter().any(|s| s == k) { out.set_str(k, v.clone()); } }
-            }
-            out
-        }
-        H_FROM_ENTRIES => {
-            let mut o = Val::obj();
-            for pair in arg(0).iter_values() {
-                let k = pair.get(&Val::Num(0.0));
-                let v = pair.get(&Val::Num(1.0));
-                o.set(&k, v);
-            }
-            o
-        }
-        H_ARRAY_FROM => Val::Arr(arg(0).iter_values()),
-        H_SLICE_FROM => {
-            let items = arg(0).iter_values();
-            let from = arg(1).to_num().max(0.0) as usize;
-            Val::Arr(items.into_iter().skip(from).collect())
-        }
-        H_URL => {
-            let input = arg(0).to_js_string();
-            let base = if arg(1).is_undef() { String::new() } else { arg(1).to_js_string() };
-            if input.contains("://") || base.is_empty() { return Val::Str(input); }
-            let origin_end = match base.find("://") {
-                Some(i) => base[i + 3..].find('/').map(|j| i + 3 + j).unwrap_or(base.len()),
-                None => 0,
-            };
-            let mut out = String::new();
-            if input.starts_with('/') { out.push_str(&base[..origin_end]); out.push_str(&input); return Val::Str(out); }
-            let path_end = base.rfind('/').map(|i| i + 1).unwrap_or(base.len()).max(origin_end).min(base.len());
-            out.push_str(&base[..path_end]);
-            out.push_str(&input);
-            Val::Str(out)
-        }
-        H_NUM => {
-            let name = arg(0).to_js_string();
-            let n = match a.get(1) { Some(Val::Num(n)) => *n, _ => return Val::Bool(false) };
-            Val::Bool(match name.as_str() {
-                "isInteger" => n.is_finite() && n == libm::trunc(n),
-                "isNaN" => n.is_nan(),
-                "isFinite" => n.is_finite(),
-                "isSafeInteger" => n.is_finite() && n == libm::trunc(n) && libm::fabs(n) <= 9007199254740991.0,
-                _ => false,
-            })
-        }
-        H_SET_HEADERS => {
-            if let Val::Obj(kv) = arg(0) {
-                for (k, v) in kv.iter() { cx.res_header(&Val::str(k), v); }
-            }
-            Val::Undef
-        }
-        _ => Val::Undef,
-    }
-}

package/transmute/runtime/zoo-host/src/json.rs

@@ -1,263 +0,0 @@
-//! JSON <-> `Val`. Hand-rolled: serde would triple the program size.
-use crate::val::{num_to_string, parse_decimal, Val};
-use alloc::{string::String, vec::Vec};
-
-pub fn stringify(v: &Val) -> String {
-    let mut out = String::new();
-    write(v, &mut out);
-    out
-}
-
-fn write(v: &Val, out: &mut String) {
-    match v {
-        // JSON.stringify(undefined) is undefined; inside containers we map to null.
-        Val::Undef | Val::Null => out.push_str("null"),
-        Val::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
-        Val::Num(n) => {
-            if n.is_finite() {
-                out.push_str(&num_to_string(*n))
-            } else {
-                out.push_str("null")
-            }
-        }
-        Val::Str(s) => write_str(s, out),
-        Val::Arr(a) => {
-            out.push('[');
-            for (i, x) in a.iter().enumerate() {
-                if i > 0 {
-                    out.push(',');
-                }
-                write(x, out);
-            }
-            out.push(']');
-        }
-        Val::Obj(kv) => {
-            out.push('{');
-            let mut first = true;
-            for (k, x) in kv.iter() {
-                if x.is_undef() {
-                    continue;
-                }
-                if !first {
-                    out.push(',');
-                }
-                first = false;
-                write_str(k, out);
-                out.push(':');
-                write(x, out);
-            }
-            out.push('}');
-        }
-    }
-}
-
-pub fn write_str(s: &str, out: &mut String) {
-    out.push('"');
-    for c in s.chars() {
-        match c {
-            '"' => out.push_str("\\\""),
-            '\\' => out.push_str("\\\\"),
-            '\n' => out.push_str("\\n"),
-            '\r' => out.push_str("\\r"),
-            '\t' => out.push_str("\\t"),
-            '\u{08}' => out.push_str("\\b"),
-            '\u{0c}' => out.push_str("\\f"),
-            c if (c as u32) < 0x20 => {
-                out.push_str("\\u00");
-                let b = c as u32;
-                out.push(hex((b >> 4) as u8));
-                out.push(hex((b & 0xf) as u8));
-            }
-            c => out.push(c),
-        }
-    }
-    out.push('"');
-}
-
-fn hex(n: u8) -> char {
-    b"0123456789abcdef"[n as usize] as char
-}
-
-pub fn parse(s: &str) -> Result<Val, Val> {
-    let mut p = Parser { b: s.as_bytes(), i: 0 };
-    p.ws();
-    let v = p.value()?;
-    p.ws();
-    if p.i != p.b.len() {
-        return Err(p.err("Unexpected non-whitespace character after JSON"));
-    }
-    Ok(v)
-}
-
-struct Parser<'a> {
-    b: &'a [u8],
-    i: usize,
-}
-
-impl<'a> Parser<'a> {
-    fn err(&self, msg: &str) -> Val {
-        let mut m = String::from("SyntaxError: ");
-        m.push_str(msg);
-        m.push_str(" at position ");
-        crate::fmt::push_u64(&mut m, self.i as u64);
-        Val::Str(m)
-    }
-    fn ws(&mut self) {
-        while self.i < self.b.len() && matches!(self.b[self.i], b' ' | b'\n' | b'\r' | b'\t') {
-            self.i += 1;
-        }
-    }
-    fn peek(&self) -> Option<u8> {
-        self.b.get(self.i).copied()
-    }
-    fn value(&mut self) -> Result<Val, Val> {
-        match self.peek() {
-            None => Err(self.err("Unexpected end of JSON input")),
-            Some(b'{') => self.object(),
-            Some(b'[') => self.array(),
-            Some(b'"') => Ok(Val::Str(self.string()?)),
-            Some(b't') => self.lit("true", Val::Bool(true)),
-            Some(b'f') => self.lit("false", Val::Bool(false)),
-            Some(b'n') => self.lit("null", Val::Null),
-            Some(c) if c == b'-' || c.is_ascii_digit() => self.number(),
-            Some(_) => Err(self.err("Unexpected token")),
-        }
-    }
-    fn lit(&mut self, word: &str, v: Val) -> Result<Val, Val> {
-        if self.b[self.i..].starts_with(word.as_bytes()) {
-            self.i += word.len();
-            Ok(v)
-        } else {
-            Err(self.err("Unexpected token"))
-        }
-    }
-    fn number(&mut self) -> Result<Val, Val> {
-        let start = self.i;
-        if self.peek() == Some(b'-') {
-            self.i += 1;
-        }
-        while let Some(c) = self.peek() {
-            if c.is_ascii_digit() || matches!(c, b'.' | b'e' | b'E' | b'+' | b'-') {
-                self.i += 1;
-            } else {
-                break;
-            }
-        }
-        let text = core::str::from_utf8(&self.b[start..self.i]).map_err(|_| self.err("bad number"))?;
-        parse_decimal(text).map(Val::Num).ok_or_else(|| self.err("bad number"))
-    }
-    fn string(&mut self) -> Result<String, Val> {
-        self.i += 1; // opening quote
-        let mut out: Vec<u8> = Vec::new();
-        loop {
-            let c = match self.peek() {
-                None => return Err(self.err("Unterminated string")),
-                Some(c) => c,
-            };
-            self.i += 1;
-            match c {
-                b'"' => break,
-                b'\\' => {
-                    let e = self.peek().ok_or_else(|| self.err("Unterminated string"))?;
-                    self.i += 1;
-                    match e {
-                        b'"' => out.push(b'"'),
-                        b'\\' => out.push(b'\\'),
-                        b'/' => out.push(b'/'),
-                        b'b' => out.push(8),
-                        b'f' => out.push(12),
-                        b'n' => out.push(b'\n'),
-                        b'r' => out.push(b'\r'),
-                        b't' => out.push(b'\t'),
-                        b'u' => {
-                            let mut cp = self.hex4()?;
-                            if (0xD800..0xDC00).contains(&cp) && self.b[self.i..].starts_with(b"\\u") {
-                                self.i += 2;
-                                let lo = self.hex4()?;
-                                if (0xDC00..0xE000).contains(&lo) {
-                                    cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00);
-                                }
-                            }
-                            let ch = char::from_u32(cp).unwrap_or('\u{FFFD}');
-                            let mut buf = [0u8; 4];
-                            out.extend_from_slice(ch.encode_utf8(&mut buf).as_bytes());
-                        }
-                        _ => return Err(self.err("Bad escaped character")),
-                    }
-                }
-                _ => out.push(c),
-            }
-        }
-        String::from_utf8(out).map_err(|_| self.err("Bad UTF-8 in string"))
-    }
-    fn hex4(&mut self) -> Result<u32, Val> {
-        if self.i + 4 > self.b.len() {
-            return Err(self.err("Bad unicode escape"));
-        }
-        let mut v: u32 = 0;
-        for &c in &self.b[self.i..self.i + 4] {
-            v = v * 16 + match (c as char).to_digit(16) { Some(d) => d, None => return Err(self.err("Bad unicode escape")) };
-        }
-        self.i += 4;
-        Ok(v)
-    }
-    fn array(&mut self) -> Result<Val, Val> {
-        self.i += 1;
-        let mut items = Vec::new();
-        self.ws();
-        if self.peek() == Some(b']') {
-            self.i += 1;
-            return Ok(Val::Arr(items));
-        }
-        loop {
-            self.ws();
-            items.push(self.value()?);
-            self.ws();
-            match self.peek() {
-                Some(b',') => self.i += 1,
-                Some(b']') => {
-                    self.i += 1;
-                    return Ok(Val::Arr(items));
-                }
-                _ => return Err(self.err("Expected ',' or ']'")),
-            }
-        }
-    }
-    fn object(&mut self) -> Result<Val, Val> {
-        self.i += 1;
-        let mut kv: Vec<(String, Val)> = Vec::new();
-        self.ws();
-        if self.peek() == Some(b'}') {
-            self.i += 1;
-            return Ok(Val::Obj(kv));
-        }
-        loop {
-            self.ws();
-            if self.peek() != Some(b'"') {
-                return Err(self.err("Expected property name"));
-            }
-            let k = self.string()?;
-            self.ws();
-            if self.peek() != Some(b':') {
-                return Err(self.err("Expected ':'"));
-            }
-            self.i += 1;
-            self.ws();
-            let v = self.value()?;
-            if let Some(slot) = kv.iter_mut().find(|(kk, _)| *kk == k) {
-                slot.1 = v;
-            } else {
-                kv.push((k, v));
-            }
-            self.ws();
-            match self.peek() {
-                Some(b',') => self.i += 1,
-                Some(b'}') => {
-                    self.i += 1;
-                    return Ok(Val::Obj(kv));
-                }
-                _ => return Err(self.err("Expected ',' or '}'")),
-            }
-        }
-    }
-}