mirror of
https://github.com/swc-project/swc.git
synced 2024-12-18 19:21:33 +03:00
759 lines
21 KiB
Rust
759 lines
21 KiB
Rust
#![allow(clippy::needless_update)]
|
|
|
|
use std::{
|
|
mem::take,
|
|
path::{Path, PathBuf},
|
|
};
|
|
|
|
use swc_common::{FileName, Span};
|
|
use swc_html_ast::*;
|
|
use swc_html_codegen::{
|
|
writer::basic::{BasicHtmlWriter, BasicHtmlWriterConfig, IndentType, LineFeed},
|
|
CodeGenerator, CodegenConfig, Emit,
|
|
};
|
|
use swc_html_parser::{
|
|
parse_file_as_document, parse_file_as_document_fragment, parser::ParserConfig,
|
|
};
|
|
use swc_html_visit::{VisitMut, VisitMutWith};
|
|
use testing::{assert_eq, run_test2, NormalizedOutput};
|
|
|
|
fn print_document(
|
|
input: &Path,
|
|
parser_config: Option<ParserConfig>,
|
|
writer_config: Option<BasicHtmlWriterConfig>,
|
|
codegen_config: Option<CodegenConfig>,
|
|
) {
|
|
let dir = input.parent().unwrap();
|
|
let parser_config = match parser_config {
|
|
Some(parser_config) => parser_config,
|
|
_ => ParserConfig::default(),
|
|
};
|
|
let writer_config = match writer_config {
|
|
Some(writer_config) => writer_config,
|
|
_ => BasicHtmlWriterConfig::default(),
|
|
};
|
|
let codegen_config = match codegen_config {
|
|
Some(codegen_config) => codegen_config,
|
|
_ => CodegenConfig::default(),
|
|
};
|
|
let output = if codegen_config.minify {
|
|
dir.join(format!(
|
|
"output.min.{}",
|
|
input.extension().unwrap().to_string_lossy()
|
|
))
|
|
} else {
|
|
dir.join(format!(
|
|
"output.{}",
|
|
input.extension().unwrap().to_string_lossy()
|
|
))
|
|
};
|
|
|
|
run_test2(false, |cm, handler| {
|
|
let fm = cm.load_file(input).unwrap();
|
|
let mut errors = vec![];
|
|
let mut document: Document =
|
|
parse_file_as_document(&fm, parser_config, &mut errors).unwrap();
|
|
|
|
for err in take(&mut errors) {
|
|
err.to_diagnostics(&handler).emit();
|
|
}
|
|
|
|
let mut html_str = String::new();
|
|
let wr = BasicHtmlWriter::new(&mut html_str, None, writer_config);
|
|
let mut gen = CodeGenerator::new(wr, codegen_config);
|
|
|
|
gen.emit(&document).unwrap();
|
|
|
|
let fm_output = cm.load_file(&output).unwrap();
|
|
|
|
NormalizedOutput::new_raw(html_str)
|
|
.compare_to_file(output)
|
|
.unwrap();
|
|
|
|
let mut errors = vec![];
|
|
let mut document_parsed_again =
|
|
parse_file_as_document(&fm_output, parser_config, &mut errors).map_err(|err| {
|
|
err.to_diagnostics(&handler).emit();
|
|
})?;
|
|
|
|
for error in take(&mut errors) {
|
|
error.to_diagnostics(&handler).emit();
|
|
}
|
|
|
|
document.visit_mut_with(&mut DropSpan);
|
|
document_parsed_again.visit_mut_with(&mut DropSpan);
|
|
|
|
assert_eq!(document, document_parsed_again);
|
|
|
|
Ok(())
|
|
})
|
|
.unwrap();
|
|
}
|
|
|
|
fn print_document_fragment(
|
|
input: &Path,
|
|
context_element: Element,
|
|
parser_config: Option<ParserConfig>,
|
|
writer_config: Option<BasicHtmlWriterConfig>,
|
|
codegen_config: Option<CodegenConfig>,
|
|
) {
|
|
let dir = input.parent().unwrap();
|
|
let parser_config = match parser_config {
|
|
Some(parser_config) => parser_config,
|
|
_ => ParserConfig::default(),
|
|
};
|
|
let writer_config = match writer_config {
|
|
Some(writer_config) => writer_config,
|
|
_ => BasicHtmlWriterConfig::default(),
|
|
};
|
|
let codegen_config = match codegen_config {
|
|
Some(codegen_config) => codegen_config,
|
|
_ => CodegenConfig::default(),
|
|
};
|
|
let output = if codegen_config.minify {
|
|
dir.join(format!(
|
|
"output.min.{}",
|
|
input.extension().unwrap().to_string_lossy()
|
|
))
|
|
} else {
|
|
dir.join(format!(
|
|
"output.{}",
|
|
input.extension().unwrap().to_string_lossy()
|
|
))
|
|
};
|
|
|
|
run_test2(false, |cm, handler| {
|
|
let fm = cm.load_file(input).unwrap();
|
|
let mut errors = vec![];
|
|
let mut document_fragment = parse_file_as_document_fragment(
|
|
&fm,
|
|
&context_element,
|
|
DocumentMode::NoQuirks,
|
|
None,
|
|
parser_config,
|
|
&mut errors,
|
|
)
|
|
.unwrap();
|
|
|
|
for err in take(&mut errors) {
|
|
err.to_diagnostics(&handler).emit();
|
|
}
|
|
|
|
let mut html_str = String::new();
|
|
let wr = BasicHtmlWriter::new(&mut html_str, None, writer_config);
|
|
let mut gen = CodeGenerator::new(wr, codegen_config);
|
|
|
|
gen.emit(&document_fragment).unwrap();
|
|
|
|
let fm_output = cm.load_file(&output).unwrap();
|
|
|
|
NormalizedOutput::new_raw(html_str)
|
|
.compare_to_file(output)
|
|
.unwrap();
|
|
|
|
let mut errors = vec![];
|
|
let mut document_fragment_parsed_again = parse_file_as_document_fragment(
|
|
&fm_output,
|
|
&context_element,
|
|
DocumentMode::NoQuirks,
|
|
None,
|
|
parser_config,
|
|
&mut errors,
|
|
)
|
|
.map_err(|err| {
|
|
err.to_diagnostics(&handler).emit();
|
|
})?;
|
|
|
|
for error in take(&mut errors) {
|
|
error.to_diagnostics(&handler).emit();
|
|
}
|
|
|
|
document_fragment.visit_mut_with(&mut DropSpan);
|
|
document_fragment_parsed_again.visit_mut_with(&mut DropSpan);
|
|
|
|
assert_eq!(document_fragment, document_fragment_parsed_again);
|
|
|
|
Ok(())
|
|
})
|
|
.unwrap();
|
|
}
|
|
|
|
fn verify_document(
|
|
input: &Path,
|
|
parser_config: Option<ParserConfig>,
|
|
writer_config: Option<BasicHtmlWriterConfig>,
|
|
codegen_config: Option<CodegenConfig>,
|
|
ignore_errors: bool,
|
|
) {
|
|
let parser_config = match parser_config {
|
|
Some(parser_config) => parser_config,
|
|
_ => ParserConfig::default(),
|
|
};
|
|
let writer_config = match writer_config {
|
|
Some(writer_config) => writer_config,
|
|
_ => BasicHtmlWriterConfig::default(),
|
|
};
|
|
let codegen_config = match codegen_config {
|
|
Some(codegen_config) => codegen_config,
|
|
_ => CodegenConfig::default(),
|
|
};
|
|
|
|
testing::run_test2(false, |cm, handler| {
|
|
let fm = cm.load_file(input).unwrap();
|
|
let mut errors = vec![];
|
|
|
|
let mut document =
|
|
parse_file_as_document(&fm, parser_config, &mut errors).map_err(|err| {
|
|
err.to_diagnostics(&handler).emit();
|
|
})?;
|
|
|
|
if !ignore_errors {
|
|
for err in take(&mut errors) {
|
|
err.to_diagnostics(&handler).emit();
|
|
}
|
|
}
|
|
|
|
let mut html_str = String::new();
|
|
let wr = BasicHtmlWriter::new(&mut html_str, None, writer_config);
|
|
let mut gen = CodeGenerator::new(wr, codegen_config);
|
|
|
|
gen.emit(&document).unwrap();
|
|
|
|
let new_fm = cm.new_source_file(FileName::Anon, html_str);
|
|
let mut parsed_errors = vec![];
|
|
let mut document_parsed_again =
|
|
parse_file_as_document(&new_fm, parser_config, &mut parsed_errors).map_err(|err| {
|
|
err.to_diagnostics(&handler).emit();
|
|
})?;
|
|
|
|
if !ignore_errors {
|
|
for err in parsed_errors {
|
|
err.to_diagnostics(&handler).emit();
|
|
}
|
|
}
|
|
|
|
document.visit_mut_with(&mut DropSpan);
|
|
document_parsed_again.visit_mut_with(&mut DropSpan);
|
|
|
|
assert_eq!(document, document_parsed_again);
|
|
|
|
Ok(())
|
|
})
|
|
.unwrap();
|
|
}
|
|
|
|
fn verify_document_fragment(
|
|
input: &Path,
|
|
context_element: Element,
|
|
parser_config: Option<ParserConfig>,
|
|
writer_config: Option<BasicHtmlWriterConfig>,
|
|
codegen_config: Option<CodegenConfig>,
|
|
ignore_errors: bool,
|
|
) {
|
|
let parser_config = match parser_config {
|
|
Some(parser_config) => parser_config,
|
|
_ => ParserConfig::default(),
|
|
};
|
|
let writer_config = match writer_config {
|
|
Some(writer_config) => writer_config,
|
|
_ => BasicHtmlWriterConfig::default(),
|
|
};
|
|
let mut codegen_config = match codegen_config {
|
|
Some(codegen_config) => codegen_config,
|
|
_ => CodegenConfig::default(),
|
|
};
|
|
|
|
codegen_config.context_element = Some(&context_element);
|
|
|
|
testing::run_test2(false, |cm, handler| {
|
|
let fm = cm.load_file(input).unwrap();
|
|
let mut errors = vec![];
|
|
|
|
let mut document_fragment = parse_file_as_document_fragment(
|
|
&fm,
|
|
&context_element,
|
|
DocumentMode::NoQuirks,
|
|
None,
|
|
parser_config,
|
|
&mut errors,
|
|
)
|
|
.map_err(|err| {
|
|
err.to_diagnostics(&handler).emit();
|
|
})?;
|
|
|
|
if !ignore_errors {
|
|
for err in take(&mut errors) {
|
|
err.to_diagnostics(&handler).emit();
|
|
}
|
|
}
|
|
|
|
let mut html_str = String::new();
|
|
let wr = BasicHtmlWriter::new(&mut html_str, None, writer_config);
|
|
let mut gen = CodeGenerator::new(wr, codegen_config);
|
|
|
|
gen.emit(&document_fragment).unwrap();
|
|
|
|
let new_fm = cm.new_source_file(FileName::Anon, html_str);
|
|
let mut parsed_errors = vec![];
|
|
let mut document_fragment_parsed_again = parse_file_as_document_fragment(
|
|
&new_fm,
|
|
&context_element,
|
|
DocumentMode::NoQuirks,
|
|
None,
|
|
parser_config,
|
|
&mut parsed_errors,
|
|
)
|
|
.map_err(|err| {
|
|
err.to_diagnostics(&handler).emit();
|
|
})?;
|
|
|
|
if !ignore_errors {
|
|
for err in parsed_errors {
|
|
err.to_diagnostics(&handler).emit();
|
|
}
|
|
}
|
|
|
|
document_fragment.visit_mut_with(&mut DropSpan);
|
|
document_fragment_parsed_again.visit_mut_with(&mut DropSpan);
|
|
|
|
assert_eq!(document_fragment, document_fragment_parsed_again);
|
|
|
|
Ok(())
|
|
})
|
|
.unwrap();
|
|
}
|
|
|
|
struct DropSpan;
|
|
|
|
impl VisitMut for DropSpan {
|
|
fn visit_mut_document_type(&mut self, n: &mut DocumentType) {
|
|
n.visit_mut_children_with(self);
|
|
|
|
n.raw = None;
|
|
}
|
|
|
|
fn visit_mut_comment(&mut self, n: &mut Comment) {
|
|
n.visit_mut_children_with(self);
|
|
|
|
n.raw = None;
|
|
}
|
|
|
|
fn visit_mut_text(&mut self, n: &mut Text) {
|
|
n.visit_mut_children_with(self);
|
|
|
|
n.raw = None;
|
|
}
|
|
|
|
fn visit_mut_element(&mut self, n: &mut Element) {
|
|
n.visit_mut_children_with(self);
|
|
|
|
// In normal output we respect `is_self_closing`
|
|
// In minified output we always avoid end tag for SVG and MathML namespace
|
|
n.is_self_closing = Default::default();
|
|
}
|
|
|
|
fn visit_mut_attribute(&mut self, n: &mut Attribute) {
|
|
n.visit_mut_children_with(self);
|
|
|
|
n.raw_name = None;
|
|
n.raw_value = None;
|
|
}
|
|
|
|
fn visit_mut_span(&mut self, n: &mut Span) {
|
|
*n = Default::default()
|
|
}
|
|
}
|
|
|
|
#[testing::fixture("tests/fixture/**/input.html")]
|
|
fn test_document(input: PathBuf) {
|
|
print_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: false,
|
|
..Default::default()
|
|
}),
|
|
);
|
|
print_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: true,
|
|
..Default::default()
|
|
}),
|
|
);
|
|
}
|
|
|
|
#[testing::fixture("tests/document_fragment/**/input.html")]
|
|
fn test_document_fragment(input: PathBuf) {
|
|
let context_element = Element {
|
|
span: Default::default(),
|
|
tag_name: "template".into(),
|
|
namespace: Namespace::HTML,
|
|
attributes: vec![],
|
|
is_self_closing: false,
|
|
children: vec![],
|
|
content: None,
|
|
};
|
|
|
|
print_document_fragment(
|
|
&input,
|
|
context_element.clone(),
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: false,
|
|
..Default::default()
|
|
}),
|
|
);
|
|
print_document_fragment(
|
|
&input,
|
|
context_element,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: true,
|
|
..Default::default()
|
|
}),
|
|
);
|
|
}
|
|
|
|
#[testing::fixture("tests/options/self_closing_void_elements/true/**/input.html")]
|
|
fn test_self_closing_void_elements_true(input: PathBuf) {
|
|
print_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: false,
|
|
tag_omission: Some(false),
|
|
self_closing_void_elements: Some(true),
|
|
..Default::default()
|
|
}),
|
|
);
|
|
}
|
|
|
|
#[testing::fixture("tests/options/self_closing_void_elements/false/**/input.html")]
|
|
fn test_self_closing_void_elements_false(input: PathBuf) {
|
|
print_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: false,
|
|
self_closing_void_elements: Some(false),
|
|
..Default::default()
|
|
}),
|
|
);
|
|
}
|
|
|
|
#[testing::fixture("tests/options/quotes/true/**/input.html")]
|
|
fn test_quotes_true(input: PathBuf) {
|
|
print_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: true,
|
|
tag_omission: Some(false),
|
|
self_closing_void_elements: Some(true),
|
|
quotes: Some(true),
|
|
..Default::default()
|
|
}),
|
|
);
|
|
}
|
|
|
|
#[testing::fixture("tests/options/quotes/false/**/input.html")]
|
|
fn test_quotes_false(input: PathBuf) {
|
|
print_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: true,
|
|
tag_omission: Some(false),
|
|
self_closing_void_elements: Some(true),
|
|
quotes: Some(false),
|
|
..Default::default()
|
|
}),
|
|
);
|
|
}
|
|
|
|
#[testing::fixture("tests/options/indent_type/**/input.html")]
|
|
fn test_indent_type_option(input: PathBuf) {
|
|
print_document(
|
|
&input,
|
|
None,
|
|
Some(BasicHtmlWriterConfig {
|
|
indent_type: IndentType::Tab,
|
|
indent_width: 2,
|
|
linefeed: LineFeed::default(),
|
|
}),
|
|
None,
|
|
);
|
|
}
|
|
|
|
#[testing::fixture("../swc_html_parser/tests/fixture/**/*.html")]
|
|
fn parser_verify(input: PathBuf) {
|
|
verify_document(&input, None, None, None, false);
|
|
verify_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: true,
|
|
tag_omission: Some(false),
|
|
..Default::default()
|
|
}),
|
|
false,
|
|
);
|
|
verify_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: true,
|
|
tag_omission: Some(true),
|
|
..Default::default()
|
|
}),
|
|
false,
|
|
);
|
|
}
|
|
|
|
#[testing::fixture(
|
|
"../swc_html_parser/tests/recovery/**/*.html",
|
|
exclude(
|
|
"document_type/bogus/input.html",
|
|
"document_type/wrong-name/input.html",
|
|
"text/cr-charref-novalid/input.html",
|
|
"element/foreign-context/input.html",
|
|
"element/a-4/input.html",
|
|
"element/b-3/input.html",
|
|
)
|
|
)]
|
|
fn parser_recovery_verify(input: PathBuf) {
|
|
verify_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: true,
|
|
tag_omission: Some(false),
|
|
..Default::default()
|
|
}),
|
|
true,
|
|
);
|
|
verify_document(
|
|
&input,
|
|
None,
|
|
None,
|
|
Some(CodegenConfig {
|
|
scripting_enabled: false,
|
|
minify: true,
|
|
tag_omission: Some(true),
|
|
..Default::default()
|
|
}),
|
|
true,
|
|
);
|
|
}
|
|
|
|
// Tag omission only works for valid HTML documents (i.e. without errors)
|
|
static IGNORE_TAG_OMISSION: &[&str] = &[
|
|
"adoption01_dat.5.html",
|
|
"adoption01_dat.6.html",
|
|
"adoption01_dat.7.html",
|
|
"adoption01_dat.8.html",
|
|
"adoption02_dat.0.html",
|
|
"tests1_dat.68.html",
|
|
"tests1_dat.69.html",
|
|
"tests1_dat.70.html",
|
|
"tests1_dat.71.html",
|
|
"tests15_dat.0.html",
|
|
"tests15_dat.1.html",
|
|
"template_dat.68.html",
|
|
"tricky01_dat.6.html",
|
|
];
|
|
|
|
#[testing::fixture(
|
|
"../swc_html_parser/tests/html5lib-tests-fixture/**/*.html",
|
|
exclude(
|
|
"tests1_dat.30.html",
|
|
"tests1_dat.77.html",
|
|
"tests1_dat.90.html",
|
|
"tests1_dat.103.html",
|
|
"tests2_dat.12.html",
|
|
"tests16_dat.31.html",
|
|
"tests16_dat.32.html",
|
|
"tests16_dat.33.html",
|
|
"tests16_dat.34.html",
|
|
"tests16_dat.35.html",
|
|
"tests16_dat.36.html",
|
|
"tests16_dat.37.html",
|
|
"tests16_dat.48.html",
|
|
"tests16_dat.49.html",
|
|
"tests16_dat.50.html",
|
|
"tests16_dat.51.html",
|
|
"tests16_dat.52.html",
|
|
"tests16_dat.53.html",
|
|
"tests16_dat.130.html",
|
|
"tests16_dat.131.html",
|
|
"tests16_dat.132.html",
|
|
"tests16_dat.133.html",
|
|
"tests16_dat.134.html",
|
|
"tests16_dat.135.html",
|
|
"tests16_dat.136.html",
|
|
"tests16_dat.147.html",
|
|
"tests16_dat.148.html",
|
|
"tests16_dat.149.html",
|
|
"tests16_dat.150.html",
|
|
"tests16_dat.196.html",
|
|
"tests18_dat.7.html",
|
|
"tests18_dat.8.html",
|
|
"tests18_dat.9.html",
|
|
"tests18_dat.12.html",
|
|
"tests18_dat.21.html",
|
|
"tests19_dat.103.html",
|
|
"tests20_dat.42.html",
|
|
"tests26_dat.2.html",
|
|
"plain-text-unsafe_dat.0.html",
|
|
"template_dat.107.html",
|
|
)
|
|
)]
|
|
fn html5lib_tests_verify(input: PathBuf) {
|
|
let file_name = input.file_name().unwrap().to_string_lossy();
|
|
let scripting_enabled = file_name.contains("script_on");
|
|
let parser_config = ParserConfig {
|
|
scripting_enabled,
|
|
iframe_srcdoc: false,
|
|
allow_self_closing: false,
|
|
};
|
|
let codegen_config = CodegenConfig {
|
|
minify: false,
|
|
scripting_enabled,
|
|
..Default::default()
|
|
};
|
|
let minified_codegen_config = CodegenConfig {
|
|
minify: true,
|
|
tag_omission: Some(true),
|
|
scripting_enabled,
|
|
..Default::default()
|
|
};
|
|
let minified_codegen_config_no_tag_omission = CodegenConfig {
|
|
minify: true,
|
|
tag_omission: Some(false),
|
|
scripting_enabled,
|
|
..Default::default()
|
|
};
|
|
|
|
if file_name.contains("fragment") {
|
|
let mut context_element_namespace = Namespace::HTML;
|
|
let mut context_element_tag_name = "";
|
|
let mut splitted = file_name.split('.');
|
|
let index = splitted.clone().count() - 2;
|
|
|
|
let context_element = splitted
|
|
.nth(index)
|
|
.expect("failed to get context element from filename")
|
|
.replace("fragment_", "");
|
|
|
|
if context_element.contains('_') {
|
|
let mut splited = context_element.split('_');
|
|
|
|
if let Some(namespace) = splited.next() {
|
|
context_element_namespace = match namespace {
|
|
"math" => Namespace::MATHML,
|
|
"svg" => Namespace::SVG,
|
|
_ => {
|
|
unreachable!();
|
|
}
|
|
};
|
|
}
|
|
|
|
if let Some(tag_name) = splited.next() {
|
|
context_element_tag_name = tag_name;
|
|
}
|
|
} else {
|
|
context_element_tag_name = &context_element;
|
|
}
|
|
|
|
let context_element = Element {
|
|
span: Default::default(),
|
|
namespace: context_element_namespace,
|
|
tag_name: context_element_tag_name.into(),
|
|
attributes: vec![],
|
|
is_self_closing: false,
|
|
children: vec![],
|
|
content: None,
|
|
};
|
|
|
|
verify_document_fragment(
|
|
&input,
|
|
context_element.clone(),
|
|
Some(parser_config),
|
|
None,
|
|
Some(codegen_config),
|
|
true,
|
|
);
|
|
verify_document_fragment(
|
|
&input,
|
|
context_element.clone(),
|
|
Some(parser_config),
|
|
None,
|
|
Some(minified_codegen_config),
|
|
true,
|
|
);
|
|
verify_document_fragment(
|
|
&input,
|
|
context_element,
|
|
Some(parser_config),
|
|
None,
|
|
Some(minified_codegen_config_no_tag_omission),
|
|
true,
|
|
);
|
|
} else {
|
|
verify_document(
|
|
&input,
|
|
Some(parser_config),
|
|
None,
|
|
Some(codegen_config),
|
|
true,
|
|
);
|
|
|
|
verify_document(
|
|
&input,
|
|
Some(parser_config),
|
|
None,
|
|
Some(minified_codegen_config_no_tag_omission),
|
|
true,
|
|
);
|
|
|
|
let relative_path = input.to_string_lossy().replace('-', "_").replace('\\', "/");
|
|
|
|
if !IGNORE_TAG_OMISSION
|
|
.iter()
|
|
.any(|ignored| relative_path.contains(&**ignored))
|
|
{
|
|
verify_document(
|
|
&input,
|
|
Some(parser_config),
|
|
None,
|
|
Some(minified_codegen_config),
|
|
true,
|
|
);
|
|
}
|
|
}
|
|
}
|