@tishlang/tish 1.6.0 → 1.7.0

package/crates/tish_compile_js/src/codegen.rs

@@ -16,7 +16,9 @@ struct Codegen {
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
     matches!(
         stmt,
-        Some(Statement::Break { .. }) | Some(Statement::Return { .. }) | Some(Statement::Throw { .. })
+        Some(Statement::Break { .. })
+            | Some(Statement::Return { .. })
+            | Some(Statement::Throw { .. })
     )
 }
 
@@ -174,7 +176,12 @@ impl Codegen {
                 self.emit_statement(body)?;
                 self.indent -= 1;
             }
-            Statement::ForOf { name, iterable, body, .. } => {
+            Statement::ForOf {
+                name,
+                iterable,
+                body,
+                ..
+            } => {
                 let escaped = Self::escape_ident(name.as_ref());
                 let it = self.emit_expr(iterable)?;
                 self.writeln(&format!("for (const {} of {})", escaped, it));
@@ -204,7 +211,10 @@ impl Codegen {
                 let async_prefix = if *async_ { "async " } else { "" };
                 let escaped = Self::escape_ident(name.as_ref());
                 let params_str = self.emit_params(params, rest_param.as_ref())?;
-                self.writeln(&format!("{}function {} ({}) {{", async_prefix, escaped, params_str));
+                self.writeln(&format!(
+                    "{}function {} ({}) {{",
+                    async_prefix, escaped, params_str
+                ));
                 self.indent += 1;
                 if *async_ {
                     self.in_async = true;
@@ -337,9 +347,7 @@ impl Codegen {
                 let parts: Vec<String> = elements
                     .iter()
                     .map(|el| match el {
-                        Some(DestructElement::Ident(n)) => {
-                            Ok(Self::escape_ident(n.as_ref()))
-                        }
+                        Some(DestructElement::Ident(n)) => Ok(Self::escape_ident(n.as_ref())),
                         Some(DestructElement::Pattern(p)) => self.emit_destruct_pattern(p),
                         Some(DestructElement::Rest(n)) => {
                             Ok(format!("...{}", Self::escape_ident(n.as_ref())))
@@ -385,7 +393,9 @@ impl Codegen {
                 Literal::Null => "null".to_string(),
             },
             Expr::Ident { name, .. } => Self::escape_ident(name.as_ref()),
-            Expr::Binary { left, op, right, .. } => {
+            Expr::Binary {
+                left, op, right, ..
+            } => {
                 let l = self.emit_expr(left)?;
                 let r = self.emit_expr(right)?;
                 let op_str = match op {
@@ -451,7 +461,9 @@ impl Codegen {
                 let obj = self.emit_expr(object)?;
                 let expr = match prop {
                     MemberProp::Name(p) => {
-                        if p.parse::<u32>().is_ok() || !p.chars().all(|c| c.is_alphanumeric() || c == '_') {
+                        if p.parse::<u32>().is_ok()
+                            || !p.chars().all(|c| c.is_alphanumeric() || c == '_')
+                        {
                             format!("{}[{:?}]", obj, p.as_ref())
                         } else {
                             let sep = if *optional { "?." } else { "." };
@@ -548,7 +560,9 @@ impl Codegen {
             Expr::PrefixDec { name, .. } => {
                 format!("--{}", Self::escape_ident(name.as_ref()))
             }
-            Expr::CompoundAssign { name, op, value, .. } => {
+            Expr::CompoundAssign {
+                name, op, value, ..
+            } => {
                 let n = Self::escape_ident(name.as_ref());
                 let v = self.emit_expr(value)?;
                 let op_str = match op {
@@ -560,7 +574,9 @@ impl Codegen {
                 };
                 format!("({} {} {})", n, op_str, v)
             }
-            Expr::LogicalAssign { name, op, value, .. } => {
+            Expr::LogicalAssign {
+                name, op, value, ..
+            } => {
                 let n = Self::escape_ident(name.as_ref());
                 let v = self.emit_expr(value)?;
                 let op_str = match op {
@@ -570,7 +586,12 @@ impl Codegen {
                 };
                 format!("({} {} {})", n, op_str, v)
             }
-            Expr::MemberAssign { object, prop, value, .. } => {
+            Expr::MemberAssign {
+                object,
+                prop,
+                value,
+                ..
+            } => {
                 let obj = self.emit_expr(object)?;
                 let val = self.emit_expr(value)?;
                 format!("({}.{} = {})", obj, prop.as_ref(), val)
@@ -652,7 +673,6 @@ impl Codegen {
             CallArg::Spread(e) => Ok(format!("...{}", self.emit_expr(e)?)),
         }
     }
-
 }
 
 /// Compile a single program (no imports) to JavaScript. JSX lowers to `h` / `Fragment` (Lattish).
@@ -679,7 +699,8 @@ pub fn compile_project_with_jsx(
         .map_err(|e| CompileError { message: e })?;
     tishlang_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
     let program = {
-        let prog = tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
+        let prog =
+            tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
         if optimize {
             tishlang_opt::optimize(&prog)
         } else {

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -11,7 +11,11 @@ mod tests {
         let src = r#"fn X() { return <div class="a">{"hi"}</div> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"), "{}", js);
+        assert!(
+            js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"),
+            "{}",
+            js
+        );
         assert!(!js.contains("function __h("));
     }
 
@@ -57,7 +61,11 @@ mod tests {
         let src = r#"fn X() { return <p>work!</p> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains(r#""work!""#), "expected 'work!', got: {}", &js[..400.min(js.len())]);
+        assert!(
+            js.contains(r#""work!""#),
+            "expected 'work!', got: {}",
+            &js[..400.min(js.len())]
+        );
     }
 
     #[test]
@@ -65,7 +73,11 @@ mod tests {
         let src = r#"fn X() { return <p>hello 😔</p> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("😔"), "expected emoji, got: {}", &js[..400.min(js.len())]);
+        assert!(
+            js.contains("😔"),
+            "expected emoji, got: {}",
+            &js[..400.min(js.len())]
+        );
     }
 
     #[test]
@@ -93,10 +105,22 @@ mod tests {
         let src = r#"fn X() { return <div class="x">{"a"}</div> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("h(\"div\", { class: \"x\" }"), "{}", &js[..500.min(js.len())]);
+        assert!(
+            js.contains("h(\"div\", { class: \"x\" }"),
+            "{}",
+            &js[..500.min(js.len())]
+        );
         assert!(!js.contains("__vdom_h"), "{}", &js[..600.min(js.len())]);
-        assert!(!js.contains("window.__LATTISH_JSX_VDOM"), "{}", &js[..600.min(js.len())]);
-        assert!(!js.contains("__lattishVdomPatch"), "{}", &js[..600.min(js.len())]);
+        assert!(
+            !js.contains("window.__LATTISH_JSX_VDOM"),
+            "{}",
+            &js[..600.min(js.len())]
+        );
+        assert!(
+            !js.contains("__lattishVdomPatch"),
+            "{}",
+            &js[..600.min(js.len())]
+        );
     }
 
     /// Component calls like {Panel()} return DOM elements. Wrapping in String() produces [object HTMLDivElement].

package/crates/tish_compiler_wasm/src/lib.rs

@@ -14,29 +14,34 @@ use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub fn compile_to_bytecode(source: &str) -> Result<String, JsValue> {
-    let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let program =
+        tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
     let program = tishlang_opt::optimize(&program);
-    let chunk = tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let chunk =
+        tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
     Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
 }
 
 #[wasm_bindgen]
 pub fn compile_to_js(source: &str) -> Result<String, JsValue> {
-    let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    tishlang_compile_js::compile_with_jsx(&program, true)
-        .map_err(|e| JsValue::from_str(&e.message))
+    let program =
+        tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    tishlang_compile_js::compile_with_jsx(&program, true).map_err(|e| JsValue::from_str(&e.message))
 }
 
 #[wasm_bindgen]
-pub fn compile_to_bytecode_with_imports(entry_path: &str, files_json: &str) -> Result<String, JsValue> {
+pub fn compile_to_bytecode_with_imports(
+    entry_path: &str,
+    files_json: &str,
+) -> Result<String, JsValue> {
     let files: HashMap<String, String> = serde_json::from_str(files_json)
         .map_err(|e| JsValue::from_str(&format!("Invalid files JSON: {}", e)))?;
-    let modules = resolve_virtual(entry_path, &files)
-        .map_err(|e| JsValue::from_str(&e))?;
+    let modules = resolve_virtual(entry_path, &files).map_err(|e| JsValue::from_str(&e))?;
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
     let program = tishlang_opt::optimize(&program);
-    let chunk = tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let chunk =
+        tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
     Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
 }
 
@@ -44,11 +49,9 @@ pub fn compile_to_bytecode_with_imports(entry_path: &str, files_json: &str) -> R
 pub fn compile_to_js_with_imports(entry_path: &str, files_json: &str) -> Result<String, JsValue> {
     let files: HashMap<String, String> = serde_json::from_str(files_json)
         .map_err(|e| JsValue::from_str(&format!("Invalid files JSON: {}", e)))?;
-    let modules = resolve_virtual(entry_path, &files)
-        .map_err(|e| JsValue::from_str(&e))?;
+    let modules = resolve_virtual(entry_path, &files).map_err(|e| JsValue::from_str(&e))?;
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
     let program = tishlang_opt::optimize(&program);
-    tishlang_compile_js::compile_with_jsx(&program, true)
-        .map_err(|e| JsValue::from_str(&e.message))
+    tishlang_compile_js::compile_with_jsx(&program, true).map_err(|e| JsValue::from_str(&e.message))
 }

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -109,10 +109,16 @@ pub fn resolve_virtual(
         if files.contains_key(&with_ext) {
             with_ext
         } else {
-            return Err(format!("Entry file '{}' not in virtual file map", entry_path));
+            return Err(format!(
+                "Entry file '{}' not in virtual file map",
+                entry_path
+            ));
         }
     } else {
-        return Err(format!("Entry file '{}' not in virtual file map", entry_path));
+        return Err(format!(
+            "Entry file '{}' not in virtual file map",
+            entry_path
+        ));
     };
 
     let mut visited = HashSet::new();
@@ -148,9 +154,9 @@ fn load_module_recursive(
     }
     visited.insert(module_path.to_string());
 
-    let source = files.get(module_path).ok_or_else(|| {
-        format!("Module '{}' not in virtual file map", module_path)
-    })?;
+    let source = files
+        .get(module_path)
+        .ok_or_else(|| format!("Module '{}' not in virtual file map", module_path))?;
     let program = tishlang_parser::parse(source.trim())
         .map_err(|e| format!("Parse error in {}: {}", module_path, e))?;
 
@@ -162,13 +168,7 @@ fn load_module_recursive(
             }
             let dep_key = resolve_import_to_key(from, from_dir, files)?;
             if !path_to_module.contains_key(&dep_key) {
-                load_module_recursive(
-                    &dep_key,
-                    files,
-                    visited,
-                    path_to_module,
-                    load_order,
-                )?;
+                load_module_recursive(&dep_key, files, visited, path_to_module, load_order)?;
             }
         }
     }
@@ -197,11 +197,11 @@ pub fn detect_cycles_virtual(modules: &[VirtualModule]) -> Result<(), String> {
             &mut stack,
             &mut HashSet::new(),
         )? {
-            let path_names: Vec<_> = stack
-                .iter()
-                .map(|&i| modules[i].path.clone())
-                .collect();
-            return Err(format!("Circular import detected: {}", path_names.join(" -> ")));
+            let path_names: Vec<_> = stack.iter().map(|&i| modules[i].path.clone()).collect();
+            return Err(format!(
+                "Circular import detected: {}",
+                path_names.join(" -> ")
+            ));
         }
     }
     Ok(())
@@ -231,14 +231,8 @@ fn has_cycle_from(
                     stack.push(dep_idx);
                     let dep = &modules[dep_idx];
                     let dep_dir = parent_dir(&dep.path);
-                    if has_cycle_from(
-                        dep_dir,
-                        &dep.program,
-                        path_to_idx,
-                        modules,
-                        stack,
-                        visiting,
-                    )? {
+                    if has_cycle_from(dep_dir, &dep.program, path_to_idx, modules, stack, visiting)?
+                    {
                         return Ok(true);
                     }
                     stack.pop();
@@ -307,7 +301,11 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
         let dir = parent_dir(&module.path);
         for stmt in &module.program.statements {
             match stmt {
-                Statement::Import { specifiers, from, span } => {
+                Statement::Import {
+                    specifiers,
+                    from,
+                    span,
+                } => {
                     if is_native_import(from) {
                         let canonical_spec =
                             normalize_builtin_spec(from).unwrap_or_else(|| from.to_string());
@@ -387,18 +385,13 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                     name: ns.clone(),
                                     mutable: false,
                                     type_ann: None,
-                                    init: Some(Expr::Object {
-                                        props,
-                                        span: *span,
-                                    }),
+                                    init: Some(Expr::Object { props, span: *span }),
                                     span: *span,
                                 });
                             }
                             ImportSpecifier::Default(bind) => {
-                                let source = dep_exports
-                                    .get("default")
-                                    .cloned()
-                                    .ok_or_else(|| {
+                                let source =
+                                    dep_exports.get("default").cloned().ok_or_else(|| {
                                         format!("Module '{}' has no default export", from)
                                     })?;
                                 statements.push(Statement::VarDecl {
@@ -415,21 +408,19 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                         }
                     }
                 }
-                Statement::Export { declaration, .. } => {
-                    match declaration.as_ref() {
-                        ExportDeclaration::Named(s) => statements.push(*s.clone()),
-                        ExportDeclaration::Default(e) => {
-                            let default_name = format!("__default_{}", idx);
-                            statements.push(Statement::VarDecl {
-                                name: Arc::from(default_name),
-                                mutable: false,
-                                type_ann: None,
-                                init: Some((*e).clone()),
-                                span: e.span(),
-                            });
-                        }
+                Statement::Export { declaration, .. } => match declaration.as_ref() {
+                    ExportDeclaration::Named(s) => statements.push(*s.clone()),
+                    ExportDeclaration::Default(e) => {
+                        let default_name = format!("__default_{}", idx);
+                        statements.push(Statement::VarDecl {
+                            name: Arc::from(default_name),
+                            mutable: false,
+                            type_ann: None,
+                            init: Some((*e).clone()),
+                            span: e.span(),
+                        });
                     }
-                }
+                },
                 _ => statements.push(stmt.clone()),
             }
         }

package/crates/tish_core/src/json.rs

@@ -228,7 +228,7 @@ fn parse_number(input: &str) -> Result<(Value, &str), String> {
 
     let num_str: String = chars[..end].iter().collect();
     let byte_len: usize = chars[..end].iter().map(|c| c.len_utf8()).sum();
-    
+
     num_str
         .parse::<f64>()
         .map(|n| (Value::Number(n), &input[byte_len..]))
@@ -306,7 +306,9 @@ mod tests {
         assert!(matches!(json_parse("true").unwrap(), Value::Bool(true)));
         assert!(matches!(json_parse("false").unwrap(), Value::Bool(false)));
         assert!(matches!(json_parse("42").unwrap(), Value::Number(n) if n == 42.0));
-        assert!(matches!(json_parse("\"hello\"").unwrap(), Value::String(s) if s.as_ref() == "hello"));
+        assert!(
+            matches!(json_parse("\"hello\"").unwrap(), Value::String(s) if s.as_ref() == "hello")
+        );
     }
 
     #[test]
@@ -315,7 +317,7 @@ mod tests {
         let value = json_parse(original).unwrap();
         let stringified = json_stringify(&value);
         let reparsed = json_parse(&stringified).unwrap();
-        
+
         match (&value, &reparsed) {
             (Value::Object(a), Value::Object(b)) => {
                 assert_eq!(a.borrow().len(), b.borrow().len());

package/crates/tish_core/src/lib.rs

@@ -10,6 +10,6 @@ mod uri;
 mod value;
 
 pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
-pub use value::*;
 pub use json::{json_parse, json_stringify};
 pub use uri::{percent_decode, percent_encode};
+pub use value::*;

package/crates/tish_core/src/uri.rs

@@ -10,13 +10,13 @@ pub fn percent_decode(input: &str) -> Result<String, String> {
         "%2F", "%2f", // /
         "%3F", "%3f", // ?
         "%3A", "%3a", // :
-        "%40",        // @
-        "%26",        // &
+        "%40", // @
+        "%26", // &
         "%3D", "%3d", // =
         "%2B", "%2b", // +
-        "%24",        // $
+        "%24", // $
         "%2C", "%2c", // ,
-        "%23",        // #
+        "%23", // #
     ];
 
     let mut result = String::with_capacity(input.len());
@@ -46,11 +46,14 @@ pub fn percent_decode(input: &str) -> Result<String, String> {
                     None => return Err("URIError: malformed URI sequence".to_string()),
                 }
             }
-            
+
             if hex.len() == 2 {
                 let encoded = format!("%{}", hex);
                 // Check if this is a reserved character that should NOT be decoded
-                if RESERVED_ENCODED.iter().any(|r| r.eq_ignore_ascii_case(&encoded)) {
+                if RESERVED_ENCODED
+                    .iter()
+                    .any(|r| r.eq_ignore_ascii_case(&encoded))
+                {
                     result.push_str(&encoded);
                 } else if let Ok(byte) = u8::from_str_radix(&hex, 16) {
                     result.push(byte as char);

package/crates/tish_core/src/value.rs

@@ -54,29 +54,70 @@ impl RegExpFlags {
         let mut result = Self::default();
         for c in flags.chars() {
             match c {
-                'g' => { if result.global { return Err(format!("duplicate flag '{}'", c)); } result.global = true; }
-                'i' => { if result.ignore_case { return Err(format!("duplicate flag '{}'", c)); } result.ignore_case = true; }
-                'm' => { if result.multiline { return Err(format!("duplicate flag '{}'", c)); } result.multiline = true; }
-                's' => { if result.dot_all { return Err(format!("duplicate flag '{}'", c)); } result.dot_all = true; }
-                'u' => { if result.unicode { return Err(format!("duplicate flag '{}'", c)); } result.unicode = true; }
-                'y' => { if result.sticky { return Err(format!("duplicate flag '{}'", c)); } result.sticky = true; }
+                'g' => {
+                    if result.global {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.global = true;
+                }
+                'i' => {
+                    if result.ignore_case {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.ignore_case = true;
+                }
+                'm' => {
+                    if result.multiline {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.multiline = true;
+                }
+                's' => {
+                    if result.dot_all {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.dot_all = true;
+                }
+                'u' => {
+                    if result.unicode {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.unicode = true;
+                }
+                'y' => {
+                    if result.sticky {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.sticky = true;
+                }
                 _ => return Err(format!("unknown flag '{}'", c)),
             }
         }
         Ok(result)
     }
-
 }
 
 #[cfg(feature = "regex")]
 impl std::fmt::Display for RegExpFlags {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.global { f.write_str("g")?; }
-        if self.ignore_case { f.write_str("i")?; }
-        if self.multiline { f.write_str("m")?; }
-        if self.dot_all { f.write_str("s")?; }
-        if self.unicode { f.write_str("u")?; }
-        if self.sticky { f.write_str("y")?; }
+        if self.global {
+            f.write_str("g")?;
+        }
+        if self.ignore_case {
+            f.write_str("i")?;
+        }
+        if self.multiline {
+            f.write_str("m")?;
+        }
+        if self.dot_all {
+            f.write_str("s")?;
+        }
+        if self.unicode {
+            f.write_str("u")?;
+        }
+        if self.sticky {
+            f.write_str("y")?;
+        }
         Ok(())
     }
 }
@@ -96,23 +137,36 @@ impl TishRegExp {
     pub fn new(pattern: &str, flags_str: &str) -> Result<Self, String> {
         let flags = RegExpFlags::from_string(flags_str)?;
         let mut regex_pattern = pattern.to_string();
-        
+
         if flags.ignore_case || flags.multiline || flags.dot_all {
             let mut flag_prefix = String::from("(?");
-            if flags.ignore_case { flag_prefix.push('i'); }
-            if flags.multiline { flag_prefix.push('m'); }
-            if flags.dot_all { flag_prefix.push('s'); }
+            if flags.ignore_case {
+                flag_prefix.push('i');
+            }
+            if flags.multiline {
+                flag_prefix.push('m');
+            }
+            if flags.dot_all {
+                flag_prefix.push('s');
+            }
             flag_prefix.push(')');
             regex_pattern = format!("{}{}", flag_prefix, regex_pattern);
         }
-        
-        let regex = Regex::new(&regex_pattern)
-            .map_err(|e| format!("Invalid regular expression: {}", e))?;
-        
-        Ok(Self { source: pattern.to_string(), flags, regex: Arc::new(regex), last_index: 0 })
+
+        let regex =
+            Regex::new(&regex_pattern).map_err(|e| format!("Invalid regular expression: {}", e))?;
+
+        Ok(Self {
+            source: pattern.to_string(),
+            flags,
+            regex: Arc::new(regex),
+            last_index: 0,
+        })
     }
 
-    pub fn flags_string(&self) -> String { self.flags.to_string() }
+    pub fn flags_string(&self) -> String {
+        self.flags.to_string()
+    }
 
     pub fn test(&mut self, input: &str) -> bool {
         if self.flags.global || self.flags.sticky {
@@ -121,10 +175,10 @@ impl TishRegExp {
                 self.last_index = 0;
                 return false;
             }
-            
+
             let byte_start: usize = input.chars().take(start).map(|c| c.len_utf8()).sum();
             let search_str = &input[byte_start..];
-            
+
             match self.regex.find(search_str) {
                 Ok(Some(m)) => {
                     if self.flags.sticky && m.start() != 0 {
@@ -176,7 +230,12 @@ impl std::fmt::Debug for Value {
             Value::Object(obj) => write!(f, "Object({:?})", obj.borrow()),
             Value::Function(_) => write!(f, "Function"),
             #[cfg(feature = "regex")]
-            Value::RegExp(re) => write!(f, "RegExp(/{}/{})", re.borrow().source, re.borrow().flags_string()),
+            Value::RegExp(re) => write!(
+                f,
+                "RegExp(/{}/{})",
+                re.borrow().source,
+                re.borrow().flags_string()
+            ),
             Value::Promise(_) => write!(f, "Promise"),
             Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
         }
@@ -202,7 +261,8 @@ impl Value {
             Value::Bool(b) => b.to_string(),
             Value::Null => "null".to_string(),
             Value::Array(arr) => {
-                let inner: Vec<String> = arr.borrow().iter().map(|v| v.to_display_string()).collect();
+                let inner: Vec<String> =
+                    arr.borrow().iter().map(|v| v.to_display_string()).collect();
                 format!("[{}]", inner.join(", "))
             }
             Value::Object(obj) => {
@@ -378,7 +438,11 @@ impl Value {
                     "trim".into(),
                 ]
             }
-            Value::Number(_) => vec!["toFixed".into(), "toExponential".into(), "toPrecision".into()],
+            Value::Number(_) => vec![
+                "toFixed".into(),
+                "toExponential".into(),
+                "toPrecision".into(),
+            ],
             _ => vec![],
         }
     }