@ape-egg/vibe 2.1.22 → 3.0.0

package/compiler/src/config.rs

@@ -1,239 +0,0 @@
-use serde::{Deserialize, Serialize};
-use std::fs;
-use std::path::PathBuf;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum ConfigError {
-    #[error("Failed to read package.json: {0}")]
-    ReadError(#[from] std::io::Error),
-    #[error("Failed to parse package.json: {0}")]
-    ParseError(#[from] serde_json::Error),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct VibeCompilerConfig {
-    #[serde(default = "default_source")]
-    pub source: String,
-    #[serde(default = "default_output")]
-    pub output: String,
-    #[serde(default = "default_components")]
-    pub components: String,
-    #[serde(default = "default_pages")]
-    pub pages: String,
-    #[serde(default = "default_assets")]
-    pub assets: String,
-    #[serde(default)]
-    pub root: Option<String>,
-    #[serde(default)]
-    pub minify: bool,
-    #[serde(default)]
-    pub elements_as_is: bool,
-    #[serde(default)]
-    pub source_maps: bool,
-    #[serde(default)]
-    pub reserved_elements: Vec<String>,
-    #[serde(default)]
-    pub skip_files: Vec<String>,
-    #[serde(default)]
-    pub node_modules_as_is: bool,
-    #[serde(default)]
-    pub components_as_is: bool,
-    #[serde(default)]
-    pub runtime_as_is: bool,
-    #[serde(default)]
-    pub iterations_as_is: bool,
-    #[serde(default)]
-    pub no_clean: bool,
-    #[serde(default)]
-    pub fouc_as_is: bool,
-}
-
-fn default_source() -> String { "./".to_string() }
-fn default_output() -> String { "./compiled".to_string() }
-fn default_components() -> String { "components".to_string() }
-fn default_pages() -> String { "pages".to_string() }
-fn default_assets() -> String { "assets".to_string() }
-
-/// Get list of standard HTML5 elements + "component"
-/// Component names matching these are reserved and not allowed
-pub fn get_default_reserved_elements() -> Vec<String> {
-    vec![
-        "a", "abbr", "address", "area", "article", "aside", "audio",
-        "b", "base", "bdi", "bdo", "blockquote", "body", "br", "button",
-        "canvas", "caption", "cite", "code", "col", "colgroup",
-        "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt",
-        "em", "embed",
-        "fieldset", "figcaption", "figure", "footer", "form",
-        "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html",
-        "i", "iframe", "img", "input", "ins",
-        "kbd",
-        "label", "legend", "li", "link",
-        "main", "map", "mark", "menu", "meta", "meter",
-        "nav", "noscript",
-        "object", "ol", "optgroup", "option", "output",
-        "p", "param", "picture", "pre", "progress",
-        "q",
-        "rp", "rt", "ruby",
-        "s", "samp", "script", "search", "section", "select", "slot", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "svg",
-        "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track",
-        "u", "ul",
-        "var", "video",
-        "wbr",
-        "component", // Always reserved
-    ].into_iter().map(|s| s.to_string()).collect()
-}
-
-impl Default for VibeCompilerConfig {
-    fn default() -> Self {
-        Self {
-            source: default_source(),
-            output: default_output(),
-            components: default_components(),
-            pages: default_pages(),
-            assets: default_assets(),
-            root: None,
-            minify: false,
-            elements_as_is: false,
-            source_maps: false,
-            reserved_elements: vec![],
-            skip_files: vec![],
-            node_modules_as_is: false,
-            components_as_is: false,
-            runtime_as_is: false,
-            iterations_as_is: false,
-            no_clean: false,
-            fouc_as_is: false,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Config {
-    pub source: PathBuf,
-    pub output: PathBuf,
-    pub _source_str: String, // Original config value for display
-    pub _output_str: String, // Original config value for display
-    pub components: String,
-    pub pages: String,
-    pub _assets: String,
-    pub root: Option<String>,
-    pub minify: bool,
-    pub elements_as_is: bool,
-    pub source_maps: bool,
-    pub reserved_elements: Vec<String>,
-    pub skip_files: Vec<String>,
-    pub node_modules_as_is: bool,
-    pub components_as_is: bool,
-    pub runtime_as_is: bool,
-    pub iterations_as_is: bool,
-    pub no_clean: bool,
-    pub fouc_as_is: bool,
-    pub working_dir: PathBuf,
-}
-
-impl Config {
-    /// Load config from package.json, or use defaults if not found
-    pub fn load(working_dir: PathBuf) -> Self {
-        let package_path = working_dir.join("package.json");
-
-        let config = if package_path.exists() {
-            fs::read_to_string(&package_path)
-                .ok()
-                .and_then(|content| serde_json::from_str::<serde_json::Value>(&content).ok())
-                .and_then(|package| package.get("vibe-compiler").cloned())
-                .and_then(|vibe_config| serde_json::from_value::<VibeCompilerConfig>(vibe_config).ok())
-                .unwrap_or_default()
-        } else {
-            VibeCompilerConfig::default()
-        };
-
-        let source_str = config.source.clone();
-        let output_str = config.output.clone();
-        let source = working_dir.join(&config.source);
-        let output = working_dir.join(&config.output);
-
-        // Combine default reserved elements with user-provided ones
-        let mut reserved_elements = get_default_reserved_elements();
-        reserved_elements.extend(config.reserved_elements);
-
-        // Combine built-in skip patterns with user-provided ones (append, not replace)
-        let mut skip_files: Vec<String> = crate::compiler::compile::SKIP_FILES
-            .iter()
-            .map(|s| s.to_string())
-            .collect();
-        skip_files.extend(config.skip_files);
-
-        Self {
-            source,
-            output,
-            _source_str: source_str,
-            _output_str: output_str,
-            components: config.components,
-            pages: config.pages,
-            _assets: config.assets,
-            root: config.root,
-            minify: config.minify,
-            elements_as_is: config.elements_as_is,
-            source_maps: config.source_maps,
-            reserved_elements,
-            skip_files,
-            node_modules_as_is: config.node_modules_as_is,
-            components_as_is: config.components_as_is,
-            runtime_as_is: config.runtime_as_is,
-            iterations_as_is: config.iterations_as_is,
-            no_clean: config.no_clean,
-            fouc_as_is: config.fouc_as_is,
-            working_dir,
-        }
-    }
-
-    pub fn components_path(&self) -> PathBuf {
-        self.source.join(&self.components)
-    }
-
-    pub fn _pages_path(&self) -> PathBuf {
-        self.source.join(&self.pages)
-    }
-
-    pub fn _assets_path(&self) -> PathBuf {
-        self.source.join(&self._assets)
-    }
-}
-
-pub fn init_config(working_dir: &PathBuf) -> Result<(), ConfigError> {
-    let package_path = working_dir.join("package.json");
-
-    if !package_path.exists() {
-        // Create minimal package.json with vibe-compiler config
-        let config = VibeCompilerConfig::default();
-        let package = serde_json::json!({
-            "vibe-compiler": config
-        });
-        let formatted = serde_json::to_string_pretty(&package)?;
-        fs::write(&package_path, formatted)?;
-        println!("Created package.json with vibe-compiler config");
-        return Ok(());
-    }
-
-    let content = fs::read_to_string(&package_path)?;
-    let mut package: serde_json::Value = serde_json::from_str(&content)?;
-
-    // Don't overwrite existing config
-    if package.get("vibe-compiler").is_some() {
-        println!("vibe-compiler config already exists in package.json");
-        return Ok(());
-    }
-
-    let default_config = VibeCompilerConfig::default();
-    let config_value = serde_json::to_value(&default_config)?;
-
-    package["vibe-compiler"] = config_value;
-
-    let formatted = serde_json::to_string_pretty(&package)?;
-    fs::write(&package_path, formatted)?;
-
-    println!("Added vibe-compiler config to package.json");
-    Ok(())
-}

package/compiler/src/main.rs

@@ -1,347 +0,0 @@
-mod config;
-mod parser;
-mod compiler;
-
-use clap::Parser as ClapParser;
-use colored::Colorize;
-use std::path::PathBuf;
-
-use config::Config;
-use compiler::Compiler;
-
-/// Track which config values were overridden by flags
-#[derive(Debug, Default)]
-struct ConfigOverrides {
-    minify: bool,
-    elements_as_is: bool,
-    source_maps: bool,
-    node_modules_as_is: bool,
-    components_as_is: bool,
-    runtime_as_is: bool,
-    iterations_as_is: bool,
-}
-
-/// Vibe Compiler - Compiles Vibe source files into optimized output
-#[derive(ClapParser, Debug)]
-#[command(name = "vibe-compile")]
-#[command(author = "Kim Korte")]
-#[command(version)]
-#[command(about = "Compiles Vibe source files into optimized output")]
-struct Args {
-    /// Working directory (defaults to current directory)
-    #[arg(long)]
-    cwd: Option<PathBuf>,
-
-    /// Watch for file changes
-    #[arg(long)]
-    watch: bool,
-
-    /// Minify output
-    #[arg(long)]
-    minify: bool,
-
-    /// Enable verbose logging with step-by-step output
-    #[arg(long)]
-    verbose: bool,
-
-    /// Keep custom HTML elements as-is (don't transform to divs for accessibility)
-    #[arg(long, name = "elements-as-is")]
-    elements_as_is: bool,
-
-    /// Generate source maps
-    #[arg(long, name = "source-maps")]
-    source_maps: bool,
-
-    /// Initialize configuration in package.json
-    #[arg(long)]
-    init: bool,
-
-    /// Custom source directory (overrides config)
-    #[arg(long)]
-    source: Option<PathBuf>,
-
-    /// Custom output directory (overrides config)
-    #[arg(long)]
-    output: Option<PathBuf>,
-
-    /// Copy node_modules as-is without production-only install (overrides config)
-    #[arg(long, name = "node-modules-as-is")]
-    node_modules_as_is: bool,
-
-    /// Keep components directory and <component> tags as-is (don't inline components)
-    #[arg(long, name = "components-as-is")]
-    components_as_is: bool,
-
-    /// Skip manifest generation - output will use runtime-only mode (no FOUC prevention)
-    #[arg(long, name = "runtime-as-is")]
-    runtime_as_is: bool,
-
-    /// Skip iteration optimization - use runtime DOM cloning instead of compiled batch functions
-    #[arg(long, name = "iterations-as-is")]
-    iterations_as_is: bool,
-
-    /// Skip cleaning output directory before compilation
-    #[arg(long, name = "no-clean", hide = true)]
-    no_clean: bool,
-
-    /// Keep FOUC prevention class/attribute in compiled output
-    #[arg(long, name = "fouc-as-is")]
-    fouc_as_is: bool,
-}
-
-fn main() {
-    let args = Args::parse();
-
-    // Determine working directory
-    let working_dir = args.cwd
-        .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));
-
-    if args.init {
-        match config::init_config(&working_dir) {
-            Ok(_) => {
-                return;
-            }
-            Err(e) => {
-                eprintln!("{}: {}", "Error".red(), e);
-                std::process::exit(1);
-            }
-        }
-    }
-
-    // Load config from package.json (uses defaults if not found)
-    let mut config = Config::load(working_dir);
-
-    // Override config with CLI args
-    if let Some(source) = args.source {
-        config.source = config.working_dir.join(source);
-    }
-    if let Some(output) = args.output {
-        config.output = config.working_dir.join(output);
-    }
-
-    // Store original config values before applying flag overrides
-    let original_minify = config.minify;
-    let original_elements_as_is = config.elements_as_is;
-    let original_source_maps = config.source_maps;
-    let original_node_modules_as_is = config.node_modules_as_is;
-    let original_components_as_is = config.components_as_is;
-    let original_runtime_as_is = config.runtime_as_is;
-    let original_iterations_as_is = config.iterations_as_is;
-
-    // Track overrides for verbose output
-    let mut overrides = ConfigOverrides::default();
-
-    if args.minify {
-        overrides.minify = !original_minify;
-        config.minify = true;
-    }
-    if args.elements_as_is {
-        overrides.elements_as_is = !original_elements_as_is;
-        config.elements_as_is = true;
-    }
-    if args.source_maps {
-        overrides.source_maps = !original_source_maps;
-        config.source_maps = true;
-    }
-    if args.node_modules_as_is {
-        overrides.node_modules_as_is = !original_node_modules_as_is;
-        config.node_modules_as_is = true;
-    }
-    if args.components_as_is {
-        overrides.components_as_is = !original_components_as_is;
-        config.components_as_is = true;
-    }
-    if args.runtime_as_is {
-        overrides.runtime_as_is = !original_runtime_as_is;
-        config.runtime_as_is = true;
-    }
-    if args.iterations_as_is {
-        overrides.iterations_as_is = !original_iterations_as_is;
-        config.iterations_as_is = true;
-    }
-    if args.no_clean {
-        config.no_clean = true;
-    }
-    if args.fouc_as_is {
-        config.fouc_as_is = true;
-    }
-
-    if args.verbose {
-        println!("{}", format!("Vibe Compiler v{}", env!("CARGO_PKG_VERSION")).cyan().bold());
-        println!();
-        println!("  {}: {}", "Working dir".cyan(), config.working_dir.display());
-        println!("  {}: {}", "Source".cyan(), config.source.display());
-        println!("  {}: {}", "Output".cyan(), config.output.display());
-        println!("  {}: {}", "Components".cyan(), config.components);
-        println!("  {}: {}", "Pages".cyan(), config.pages);
-        println!("  {}: {}", "Assets".cyan(), config._assets);
-        println!();
-
-        // Show config values (alphabetically ordered)
-        println!("{}", "Compiler config".cyan().bold());
-        println!();
-        println!("  CLI flags override package.json config");
-        println!();
-
-        fn format_bool_with_flag(final_value: bool, overridden: bool, original_value: bool) -> String {
-            if overridden {
-                format!("{} (config: {}, flag: {})", final_value.to_string().green(), original_value.to_string().yellow(), final_value.to_string().green())
-            } else {
-                format!("{} (config: {})", final_value.to_string().green(), original_value.to_string().yellow())
-            }
-        }
-
-        fn format_value_no_flag<T: std::fmt::Display>(value: T) -> String {
-            format!("{} (config: {})", value.to_string().green(), value.to_string().yellow())
-        }
-
-        fn format_reserved_elements(elements: &[String]) -> String {
-            if elements.len() <= 2 {
-                format!("{:?}", elements)
-            } else {
-                let remaining = elements.len() - 2;
-                format!("[\"component\", \"div\", ... + {} more]", remaining)
-            }
-        }
-
-        fn format_list_preview(items: &[String]) -> String {
-            if items.len() <= 2 {
-                format!("{:?}", items)
-            } else {
-                format!("[{:?}, {:?}, ... + {} more]", items[0], items[1], items.len() - 2)
-            }
-        }
-
-        // Alphabetically ordered with padding (longest key is "reservedElements" = 16 chars)
-        println!("  {}: {}", format!("{:<16}", "assets").cyan(), format_value_no_flag(&config._assets));
-        println!("  {}: {}", format!("{:<16}", "components").cyan(), format_value_no_flag(&config.components));
-        println!("  {}: {}", format!("{:<16}", "componentsAsIs").cyan(), format_bool_with_flag(config.components_as_is, overrides.components_as_is, original_components_as_is));
-        println!("  {}: {}", format!("{:<16}", "elementsAsIs").cyan(), format_bool_with_flag(config.elements_as_is, overrides.elements_as_is, original_elements_as_is));
-        println!("  {}: {}", format!("{:<16}", "iterationsAsIs").cyan(), format_bool_with_flag(config.iterations_as_is, overrides.iterations_as_is, original_iterations_as_is));
-        println!("  {}: {}", format!("{:<16}", "minify").cyan(), format_bool_with_flag(config.minify, overrides.minify, original_minify));
-        println!("  {}: {}", format!("{:<16}", "nodeModulesAsIs").cyan(), format_bool_with_flag(config.node_modules_as_is, overrides.node_modules_as_is, original_node_modules_as_is));
-        println!("  {}: {}", format!("{:<16}", "output").cyan(), format_value_no_flag(&config._output_str));
-        println!("  {}: {}", format!("{:<16}", "pages").cyan(), format_value_no_flag(&config.pages));
-        println!("  {}: {}", format!("{:<16}", "reservedElements").cyan(), format_value_no_flag(format_reserved_elements(&config.reserved_elements)));
-        println!("  {}: {}", format!("{:<16}", "root").cyan(), format_value_no_flag(config.root.as_ref().map(|s| s.as_str()).unwrap_or("null")));
-        println!("  {}: {}", format!("{:<16}", "runtimeAsIs").cyan(), format_bool_with_flag(config.runtime_as_is, overrides.runtime_as_is, original_runtime_as_is));
-        println!("  {}: {}", format!("{:<16}", "skipFiles").cyan(), format_value_no_flag(format_list_preview(&config.skip_files)));
-        println!("  {}: {}", format!("{:<16}", "source").cyan(), format_value_no_flag(&config._source_str));
-        println!("  {}: {}", format!("{:<16}", "sourceMaps").cyan(), format_bool_with_flag(config.source_maps, overrides.source_maps, original_source_maps));
-        println!();
-    } else {
-        // Show version in non-verbose mode
-        println!("{}", format!("Vibe Compiler v{}", env!("CARGO_PKG_VERSION")).cyan());
-    }
-
-    // Handle watch mode
-    if args.watch {
-        if let Err(e) = compiler::watcher::watch(config, args.verbose) {
-            eprintln!("{}: {}", "Error".red(), e);
-            std::process::exit(1);
-        }
-        return;
-    }
-
-    // Save runtime_as_is before moving config
-    let runtime_as_is = config.runtime_as_is;
-
-    let mut compiler = Compiler::new(config, args.verbose);
-
-    match compiler.compile() {
-        Ok(stats) => {
-            // Generate manifests BEFORE showing success (unless runtime-as-is is enabled)
-            let mut manifest_time_ms = 0.0;
-            let mut manifest_stats_result = None;
-            if !runtime_as_is {
-                match compiler.generate_manifests() {
-                    Ok(manifest_stats) => {
-                        manifest_time_ms = manifest_stats.total_time_ms;
-                        manifest_stats_result = Some(manifest_stats);
-                    }
-                    Err(e) => {
-                        eprintln!("\n{}: Manifest generation failed: {}", "Warning".yellow(), e);
-                        eprintln!("Compilation succeeded but manifests were not generated.");
-                        eprintln!("Use --runtime-as-is to skip manifest generation.");
-                    }
-                }
-            }
-
-            // Show success headline
-            println!("\n{}", format!("Compilation successful! (v{}) ✅", env!("CARGO_PKG_VERSION")).green().bold());
-            println!();
-
-            // Show individual phase timings (validation first, then components, HTML, manifests, copied)
-
-            // Show validation time if it happened
-            if let Some(validation_time) = stats.validation_time_ms {
-                println!("* Validated components in {:.0}ms", validation_time);
-            }
-
-            let total_components_unique = stats.internal_components_unique + stats.external_components_unique;
-
-            // Always show components line
-            if stats.components_as_is {
-                println!("* Compiled components (0 internal, 0 external) - \"components-as-is\": true");
-            } else if total_components_unique > 0 {
-                println!("* Compiled components ({} internal, {} external) in {:.0}ms",
-                    stats.internal_components_unique,
-                    stats.external_components_unique,
-                    stats.components_time_ms
-                );
-            }
-
-            if stats.files_compiled > 0 {
-                println!("* Compiled HTML ({} file{}) in {:.0}ms",
-                    stats.files_compiled,
-                    if stats.files_compiled == 1 { "" } else { "s" },
-                    stats.compile_time_ms
-                );
-            }
-
-            // Show manifest stats between HTML and Copied files
-            if let Some(manifest_stats) = manifest_stats_result {
-                println!("* Generated manifests ({} file{}, {} skipped) in {:.0}ms",
-                    manifest_stats.pages_processed,
-                    if manifest_stats.pages_processed == 1 { "" } else { "s" },
-                    manifest_stats.pages_skipped,
-                    manifest_stats.total_time_ms
-                );
-            }
-
-            if stats.files_copied > 0 {
-                println!("* Copied files ({} file{}) in {:.0}ms",
-                    stats.files_copied,
-                    if stats.files_copied == 1 { "" } else { "s" },
-                    stats.copy_time_ms
-                );
-            }
-
-            // Show node_modules handling
-            if let Some(nm_time) = stats.node_modules_time_ms {
-                if stats.node_modules_copied_as_is {
-                    println!("* copied node_modules in {:.0}ms", nm_time);
-                } else if let Some(ref pkg_manager) = stats.package_manager {
-                    println!("* {} install in {:.0}ms", pkg_manager, nm_time);
-                }
-            }
-
-            // Calculate total duration as sum of all individual operations
-            let total_duration_ms = stats.validation_time_ms.unwrap_or(0.0)
-                + stats.components_time_ms
-                + stats.compile_time_ms
-                + stats.copy_time_ms
-                + stats.node_modules_time_ms.unwrap_or(0.0)
-                + manifest_time_ms;
-
-            println!("\n{} in {:.0}ms", "Compiled".green(), total_duration_ms);
-
-            // Exit explicitly to kill background server thread
-            std::process::exit(0);
-        }
-        Err(e) => {
-            eprintln!("{}: {}", "Error".red(), e);
-            std::process::exit(1);
-        }
-    }
-}

package/compiler/src/parser/element.rs

@@ -1,96 +0,0 @@
-use std::collections::HashMap;
-use std::path::PathBuf;
-
-/// Represents a parsed Vibe element/component
-#[derive(Debug, Clone)]
-pub struct Element {
-    /// Tag name (derived from filename, e.g., "counter" from counter.html)
-    pub _tag_name: String,
-    /// Original file path
-    pub _path: PathBuf,
-    /// Raw HTML content (the inner content of the element)
-    pub content: String,
-    /// Bindings found in this element (@[property])
-    pub _bindings: Vec<String>,
-    /// Nested element references (custom tags used within this element)
-    pub _nested_elements: Vec<String>,
-}
-
-impl Element {
-    pub fn new(tag_name: String, path: PathBuf, content: String) -> Self {
-        let bindings = extract_bindings(&content);
-        let nested_elements = extract_custom_tags(&content);
-
-        Self {
-            _tag_name: tag_name,
-            _path: path,
-            content,
-            _bindings: bindings,
-            _nested_elements: nested_elements,
-        }
-    }
-}
-
-/// Extract all @[property] bindings from content
-fn extract_bindings(content: &str) -> Vec<String> {
-    let mut bindings = Vec::new();
-    let re = regex::Regex::new(r"@\[([^\]]+)\]").unwrap();
-
-    for cap in re.captures_iter(content) {
-        if let Some(m) = cap.get(1) {
-            let binding = m.as_str().to_string();
-            if !bindings.contains(&binding) {
-                bindings.push(binding);
-            }
-        }
-    }
-
-    bindings
-}
-
-/// Extract custom HTML tags (potential element references)
-/// Custom tags are lowercase with hyphens, or single-word lowercase non-standard tags
-fn extract_custom_tags(content: &str) -> Vec<String> {
-    let mut tags = Vec::new();
-    // Match opening tags: <tag-name> or <tagname (self-closing handled too)
-    let re = regex::Regex::new(r"<([a-z][a-z0-9-]*)[>\s/]").unwrap();
-
-    // Standard HTML5 elements to exclude
-    let standard_tags: std::collections::HashSet<&str> = [
-        "a", "abbr", "address", "area", "article", "aside", "audio",
-        "b", "base", "bdi", "bdo", "blockquote", "body", "br", "button",
-        "canvas", "caption", "cite", "code", "col", "colgroup",
-        "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt",
-        "em", "embed",
-        "fieldset", "figcaption", "figure", "footer", "form",
-        "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html",
-        "i", "iframe", "img", "input", "ins",
-        "kbd",
-        "label", "legend", "li", "link",
-        "main", "map", "mark", "menu", "meta", "meter",
-        "nav", "noscript",
-        "object", "ol", "optgroup", "option", "output",
-        "p", "param", "picture", "pre", "progress",
-        "q",
-        "rp", "rt", "ruby",
-        "s", "samp", "script", "search", "section", "select", "slot", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "svg",
-        "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track",
-        "u", "ul",
-        "var", "video",
-        "wbr",
-    ].into_iter().collect();
-
-    for cap in re.captures_iter(content) {
-        if let Some(m) = cap.get(1) {
-            let tag = m.as_str().to_string();
-            if !standard_tags.contains(tag.as_str()) && !tags.contains(&tag) {
-                tags.push(tag);
-            }
-        }
-    }
-
-    tags
-}
-
-/// Cache of loaded elements by tag name
-pub type ElementCache = HashMap<String, Element>;