use super::format_list::{handle_indent, handle_outdent, merge_lists};
use super::generated_json::{
export_compact_list_item_node, export_list_item_node, update_list_item_node,
};
use super::list_node::{ListType, create_list_node, is_list_node};
use super::utils::{get_new_list_start, is_nested_list_node};
use crate::LexicalError;
use crate::caret::{CaretDirection, get_sibling_caret};
use crate::caret_utils::{
SplitAtPointCaretNextOptions, insert_node_to_nearest_root_at_caret, rewind_sibling_caret,
};
use crate::error::invariant;
use crate::json::Object;
use crate::json::Value;
use crate::lexical_selection::{PointType, SelectionRef, Which, get_selection};
use crate::lexical_utils::{copy_node, set_node_key, with_writable};
use crate::node::{self, LexicalNode, NodeBase, NodeRef};
use crate::nodes::element::{ElementData, is_root_or_shadow_root};
use crate::nodes::paragraph::{ParagraphNode, create_paragraph_node};
use crate::schema::{
NodeSchema, NumberValueOptions, boolean_value, node_schema, number_value, optional,
schema_getter, schema_setter, with_accessors, with_field,
};
#[derive(Clone, Debug)]
pub struct ListItemNode {
base: NodeBase,
pub(super) element: ElementData,
pub(super) value: f64,
pub(super) checked: Option<bool>,
}
impl Default for ListItemNode {
fn default() -> Self {
ListItemNode {
base: NodeBase::default(),
element: ElementData::default(),
value: 1.0,
checked: None,
}
}
}
pub fn create_list_item_node(checked: Option<bool>) -> NodeRef {
crate::lexical_utils::replaced(set_node_key(Box::new(ListItemNode {
checked,
..ListItemNode::default()
})))
}
pub fn is_list_item_node(node: &NodeRef) -> bool {
node.get_latest().is::<ListItemNode>()
}
fn with_item<R>(node: &NodeRef, f: impl FnOnce(&ListItemNode) -> R) -> Option<R> {
node.get_latest().downcast_ref::<ListItemNode>().map(f)
}
fn set_item(node: &NodeRef, f: impl FnOnce(&mut ListItemNode)) {
if is_list_item_node(node) {
with_writable(node.get_key(), |n| {
f(n.downcast_mut::<ListItemNode>().expect("a list item"))
});
}
}
impl NodeRef {
pub fn get_list_item_value(&self) -> Option<f64> {
with_item(self, |i| i.value)
}
pub fn set_list_item_value(&self, value: f64) {
set_item(self, |i| i.value = value);
}
pub fn get_checked(&self) -> Option<bool> {
let checked = with_item(self, |i| i.checked)?;
let list_type = self.get_parent().and_then(|p| p.get_list_type());
(list_type == Some(ListType::Check)).then_some(checked == Some(true))
}
pub fn set_checked(&self, checked: Option<bool>) {
set_item(self, |i| i.checked = checked);
}
pub fn toggle_checked(&self) {
set_item(self, |i| i.checked = Some(i.checked != Some(true)));
}
}
fn get_list_item_indent(this: &NodeRef, own: f64) -> Result<f64, LexicalError> {
let Some(parent) = this.get_parent() else {
return Ok(own);
};
if !this.is_attached() {
return Ok(own);
}
let mut list_node_parent = parent.get_parent_or_throw()?;
let mut indent_level = 0.0;
while is_list_item_node(&list_node_parent) {
list_node_parent = list_node_parent
.get_parent_or_throw()?
.get_parent_or_throw()?;
indent_level += 1.0;
}
Ok(indent_level)
}
impl ListItemNode {
pub fn value(&self) -> f64 {
self.value
}
pub fn checked(&self) -> Option<bool> {
self.checked
}
fn exported_checked_and_indent(&self) -> (Option<bool>, f64) {
let this = NodeRef::new(self.base.key.clone());
let checked = this.get_checked();
let indent =
get_list_item_indent(&this, self.element.indent).unwrap_or_else(|e| panic!("{e}"));
(checked, indent)
}
fn can_merge_with(node: &NodeRef) -> bool {
is_list_item_node(node) || node.get_latest().is::<ParagraphNode>()
}
}
fn lifts_from_structure(
this: &NodeRef,
child: &NodeRef,
explicit: bool,
) -> Result<bool, LexicalError> {
if !is_list_node(child) || this.get_children_size() <= 1 {
return Ok(false);
}
if explicit {
return Ok(true);
}
let Some(editor) = crate::updates::get_active_editor() else {
return Ok(true);
};
let committed = editor.get_editor_state();
let written_now =
this.get_latest().base().written_in == crate::updates::get_active_editor_state().0.id;
Ok(!committed.0.node_map.borrow().contains_key(this.get_key()) || written_now)
}
#[allow(clippy::type_complexity)]
fn points_around(
parent: &NodeRef,
items: &[NodeRef],
) -> Result<Option<Box<dyn FnOnce() -> Result<(), LexicalError>>>, LexicalError> {
let Some(selection) = get_selection().filter(SelectionRef::is_range) else {
return Ok(None);
};
let parent_key = parent.get_key().to_owned();
let first = items[0].get_index_within_parent().unwrap_or(0);
let saved: Vec<(Which, usize)> = [Which::Anchor, Which::Focus]
.into_iter()
.filter_map(|which| {
let point = selection.point(which).expect("a range selection");
(point.point_type == PointType::Element && point.key == parent_key)
.then_some((which, point.offset))
})
.collect();
if saved.is_empty() {
return Ok(None);
}
let items = items.to_vec();
Ok(Some(Box::new(move || {
for (which, offset) in saved {
if offset <= first {
selection.point_set(which, &parent_key, offset, PointType::Element)?;
} else if offset < first + items.len() {
let item = &items[offset - first - 1];
selection.point_set(
which,
item.get_key(),
item.get_children_size(),
PointType::Element,
)?;
} else {
selection.point_set(
which,
&parent_key,
offset - items.len() + 1,
PointType::Element,
)?;
}
}
Ok(())
})))
}
thread_local! {
static LIST_ITEM_NODE_SCHEMA: NodeSchema =
build_list_item_node_schema().expect("ListItemNode's schema");
}
const MAX_LIST_ITEM_INDENT: f64 = 128.0;
pub fn list_item_node_schema() -> NodeSchema {
LIST_ITEM_NODE_SCHEMA.with(Clone::clone)
}
fn build_list_item_node_schema() -> Result<NodeSchema, LexicalError> {
node_schema(vec![
(
"checked",
with_accessors(
optional(boolean_value(false), false)?,
Some(schema_getter(|n: &ListItemNode| {
n.exported_checked_and_indent()
.0
.map_or(Value::Undefined, Value::from)
})),
Some(schema_setter(|n: &mut ListItemNode, value| {
n.checked = value.as_bool();
})),
)?,
),
(
"indent",
with_accessors(
number_value(
0.0,
NumberValueOptions {
clamp: true,
integer: true,
max: Some(MAX_LIST_ITEM_INDENT),
min: Some(0.0),
},
)?,
Some(schema_getter(|n: &ListItemNode| {
n.exported_checked_and_indent().1.into()
})),
Some(schema_setter(|_: &mut ListItemNode, _| {})),
)?
.derived(),
),
(
"value",
with_field(
number_value(1.0, NumberValueOptions::default())?,
|n: &ListItemNode| &n.value,
|n: &mut ListItemNode| &mut n.value,
)?
.derived(),
),
])
}
impl LexicalNode for ListItemNode {
fn json_schema_chain(&self) -> Vec<NodeSchema> {
vec![
list_item_node_schema(),
crate::nodes::element::element_node_schema(),
]
}
fn static_node_config_chain(&self) -> Vec<crate::structure::NodeConfigLink> {
use crate::structure::{
NodeChildEntry, NodeChildrenConfig, NodeClassRef, NodeConfigLink, StaticNodeConfig,
};
vec![NodeConfigLink::new(
"listitem",
StaticNodeConfig {
children: Some(NodeChildrenConfig::List(vec![
NodeChildEntry::Inline,
NodeChildEntry::Class(NodeClassRef::of::<super::ListNode>()),
])),
..StaticNodeConfig::default()
},
)]
}
fn get_type(&self) -> &'static str {
"listitem"
}
#[cfg(feature = "html")]
fn create_dom(
&self,
this: &NodeRef,
config: &crate::EditorConfig,
_editor: &crate::Editor,
) -> Result<crate::dom::DomNode, LexicalError> {
list_item_dom::create_dom(self, this, config)
}
#[cfg(feature = "html")]
fn export_dom(
&self,
this: &NodeRef,
editor: &crate::Editor,
) -> Result<crate::lexical_dom::DomExportOutput, LexicalError> {
list_item_dom::export_dom(self, this, editor)
}
#[cfg(feature = "html")]
fn import_dom(&self) -> Option<crate::lexical_dom::DomConversionMap> {
Some(list_item_dom::import_dom())
}
fn base(&self) -> &NodeBase {
&self.base
}
fn base_mut(&mut self) -> &mut NodeBase {
&mut self.base
}
fn element(&self) -> Option<&ElementData> {
Some(&self.element)
}
fn element_mut(&mut self) -> Option<&mut ElementData> {
Some(&mut self.element)
}
fn is_parent_required(&self) -> bool {
true
}
fn create_parent_element_node(&self) -> NodeRef {
create_list_node(ListType::Bullet, 1.0)
}
fn can_merge_when_empty(&self) -> bool {
true
}
fn extract_with_child(
&self,
this: &NodeRef,
_: &NodeRef,
selection: Option<&SelectionRef>,
_: &str,
) -> Result<bool, LexicalError> {
let Some(selection) = selection.filter(|s| s.is_range()) else {
return Ok(false);
};
let range = selection.range().expect("a range selection");
let anchor_node = range.anchor.get_node()?;
let focus_node = range.focus.get_node()?;
Ok(this.is_parent_of(&anchor_node)
&& this.is_parent_of(&focus_node)
&& crate::utf16::len(&this.get_text_content())
== crate::utf16::len(&selection.get_text_content()?))
}
fn generated_export_json(&self, compact: bool) -> Option<Object> {
let (checked, indent) = self.exported_checked_and_indent();
Some(if compact {
export_compact_list_item_node(self, checked, indent)
} else {
export_list_item_node(self, checked, indent)
})
}
fn generated_update_from_json(&mut self, json: &Object) -> bool {
update_list_item_node(self, json);
true
}
fn append(&self, this: &NodeRef, nodes: &[NodeRef]) -> Result<(), LexicalError> {
for node in nodes {
if node.is_element() && Self::can_merge_with(node) {
let children = node.get_children();
this.append(&children)?;
node.remove(false)?;
} else {
this.splice(this.get_children_size(), 0, std::slice::from_ref(node))?;
}
}
Ok(())
}
fn replace(
&self,
this: &NodeRef,
replace_with: &NodeRef,
include_children: bool,
) -> Result<NodeRef, LexicalError> {
if is_list_item_node(replace_with) {
return node::replace(this, replace_with, false);
}
this.set_indent(0.0)?;
let list = this.get_parent_or_throw()?;
if !is_list_node(&list) {
return Ok(replace_with.clone());
}
if list.get_first_child().as_ref() == Some(this) {
list.insert_before(replace_with, true)?;
} else if list.get_last_child().as_ref() == Some(this) {
list.insert_after(replace_with, true)?;
} else {
let new_list = copy_node(&list);
let mut next_sibling = this.get_next_sibling();
while let Some(node_to_append) = next_sibling {
next_sibling = node_to_append.get_next_sibling();
new_list.append(std::slice::from_ref(&node_to_append))?;
}
list.insert_after(replace_with, true)?;
replace_with.insert_after(&new_list, true)?;
}
let to_replace_key = this.get_key().to_owned();
let mut prev_size_before_children_transfer = 0;
if include_children {
invariant!(
replace_with.is_element(),
"includeChildren should only be true for ElementNodes"
);
prev_size_before_children_transfer = replace_with.get_children_size();
replace_with.splice(prev_size_before_children_transfer, 0, &this.get_children())?;
}
if include_children
&& replace_with.is_element()
&& let Some(selection) = get_selection().filter(SelectionRef::is_range)
{
for which in [Which::Anchor, Which::Focus] {
let point = selection.point(which).expect("a range selection");
if point.key == to_replace_key && point.point_type == PointType::Element {
selection.point_set(
which,
replace_with.get_key(),
prev_size_before_children_transfer + point.offset,
PointType::Element,
)?;
}
}
}
this.remove(false)?;
if list.get_children_size() == 0 {
list.remove(false)?;
}
Ok(replace_with.clone())
}
fn insert_after(
&self,
this: &NodeRef,
node: &NodeRef,
restore_selection: bool,
) -> Result<NodeRef, LexicalError> {
let list_node = this.get_parent_or_throw()?;
invariant!(
is_list_node(&list_node),
"insertAfter: list node is not parent of list item node"
);
if is_list_item_node(node) {
return node::insert_after(this, node, restore_selection);
}
let siblings = this.get_next_siblings();
list_node.insert_after(node, restore_selection)?;
if let Some(first_sibling) = siblings.first() {
let new_list_node = copy_node(&list_node);
if new_list_node.get_list_type() == Some(ListType::Number)
&& is_list_item_node(first_sibling)
{
new_list_node.set_list_start(get_new_list_start(&list_node, first_sibling));
}
for sibling in &siblings {
new_list_node.append(std::slice::from_ref(sibling))?;
}
node.insert_after(&new_list_node, restore_selection)?;
}
Ok(node.clone())
}
fn remove(&self, this: &NodeRef, preserve_empty_parent: bool) -> Result<(), LexicalError> {
let prev_sibling = this.get_previous_sibling();
let next_sibling = this.get_next_sibling();
node::remove(this, preserve_empty_parent)?;
if let (Some(prev), Some(next)) = (prev_sibling, next_sibling)
&& is_nested_list_node(&prev)
&& is_nested_list_node(&next)
{
let prev_list = prev.get_first_child().expect("a nested list");
let next_list = next.get_first_child().expect("a nested list");
if prev_list.get_list_type() == next_list.get_list_type() {
merge_lists(&prev_list, &next_list)?;
next.remove(false)?;
}
}
Ok(())
}
fn reset_on_copy_node_from(&self, this: &NodeRef, original: &NodeRef) {
if original.get_checked() == Some(true) {
this.set_checked(Some(false));
}
}
fn insert_new_after(
&self,
this: &NodeRef,
_: &SelectionRef,
restore_selection: bool,
) -> Result<Option<NodeRef>, LexicalError> {
let new_element = copy_node(this);
this.insert_after(&new_element, restore_selection)?;
Ok(Some(new_element))
}
fn collapse_at_start(&self, this: &NodeRef, _: &SelectionRef) -> Result<bool, LexicalError> {
if is_nested_list_node(this) {
return Ok(false);
}
let list_node = this.get_parent_or_throw()?;
let list_node_parent = list_node.get_parent_or_throw()?;
if is_list_item_node(&list_node_parent) {
handle_outdent(this)?;
return Ok(true);
}
let paragraph = create_paragraph_node();
paragraph.append(&this.get_children())?;
let next_siblings = this.get_next_siblings();
if !next_siblings.is_empty() {
let new_list = copy_node(&list_node);
new_list.append(&next_siblings)?;
list_node.insert_after(&new_list, true)?;
}
list_node.insert_after(¶graph, true)?;
this.remove(false)?;
if list_node.get_children_size() == 0 {
list_node.remove(false)?;
}
paragraph.select_start()?;
Ok(true)
}
fn get_indent(&self, this: &NodeRef) -> Result<f64, LexicalError> {
get_list_item_indent(this, self.element.indent)
}
fn set_indent(&self, this: &NodeRef, indent: f64) -> Result<(), LexicalError> {
let indent = indent.floor();
invariant!(
indent.partial_cmp(&0.0).is_some_and(|o| o.is_ge()),
"Indent value must be non-negative."
);
let target = indent;
let mut current_indent = this.get_indent()?;
while current_indent != target {
if current_indent < target {
handle_indent(this)?;
current_indent += 1.0;
} else {
handle_outdent(this)?;
current_indent -= 1.0;
}
}
Ok(())
}
fn internal_lifts_from_structure(&self) -> Option<crate::structure::LiftsFromStructure> {
Some(lifts_from_structure)
}
fn transform(&self, this: &NodeRef) -> Result<(), LexicalError> {
let Some(parent) = this.get_parent() else {
return Ok(());
};
if is_list_node(&parent) {
if parent.get_list_type() != Some(ListType::Check) && this.get_checked().is_some() {
this.set_checked(None);
}
return Ok(());
}
let new_parent = this.create_parent_element_node();
invariant!(
is_list_node(&new_parent),
"ListItemNode.createParentElementNode() must return a ListNode"
);
let mut children = vec![this.clone()];
for next in [false, true] {
children.reverse();
let mut sibling = if next {
this.get_next_sibling()
} else {
this.get_previous_sibling()
};
while let Some(origin) = sibling.filter(is_list_item_node) {
sibling = if next {
origin.get_next_sibling()
} else {
origin.get_previous_sibling()
};
children.push(origin);
}
}
let enforced = crate::structure::is_structure_enforced_on_active_editor();
let points = if enforced {
points_around(&parent, &children)?
} else {
None
};
this.insert_before(&new_parent, true)?;
new_parent.splice(0, 0, &children)?;
if let Some(points) = points {
points()?;
}
if enforced {
let mut n = Some(parent.clone());
while let Some(current) = n.filter(|n| !is_root_or_shadow_root(&*n.get_latest())) {
current.mark_dirty();
n = current.get_parent();
}
}
if !is_root_or_shadow_root(&*parent.get_latest()) && !enforced {
insert_node_to_nearest_root_at_caret(
&new_parent,
&rewind_sibling_caret(&get_sibling_caret(&new_parent, CaretDirection::Next))?,
&SplitAtPointCaretNextOptions {
should_split: |_, _| false,
remove_empty_destination: true,
..SplitAtPointCaretNextOptions::default()
},
)?;
if parent.is_empty() && parent.is_attached() {
parent.remove(false)?;
}
}
Ok(())
}
}
#[cfg(feature = "html")]
pub(super) mod list_item_dom {
use super::super::list_node::{ListType, is_list_node};
use super::super::utils::is_nested_list_node;
use super::{ListItemNode, create_list_item_node};
use crate::dom::DomNode;
use crate::json::{Object, Value};
use crate::lexical_dom::{
DomConversionNode, DomConversionOutput, DomExportOutput, get_document,
normalize_class_names, set_direction_from_dom, set_format_from_dom,
};
use crate::node::NodeRef;
use crate::nodes::paragraph::ParagraphNode;
use crate::set_dom_style::{get_style_object_from_css, set_dom_style_from_css};
use crate::{EditorConfig, LexicalError};
pub(crate) fn create_dom(
node: &ListItemNode,
this: &NodeRef,
config: &EditorConfig,
) -> Result<DomNode, LexicalError> {
let dom = get_document().create_element("li");
update_list_item_checked(&dom, node, this);
dom.set_attribute(
"value",
&crate::nodes::text::to_int32(node.value).to_string(),
);
set_list_item_theme_class_names(&dom, &config.theme, node, this);
let style = node.element.get_style();
if !style.is_empty() {
set_dom_style_from_css(&dom.style(), style, "");
}
apply_marker_styles(&dom, node);
Ok(dom)
}
fn apply_marker_styles(dom: &DomNode, node: &ListItemNode) {
let style = dom.style();
for (k, v) in get_style_object_from_css(node.element.get_text_style()).iter() {
style.set_property(&format!("--listitem-marker-{k}"), v, "");
}
}
pub(crate) fn export_dom(
node: &ListItemNode,
this: &NodeRef,
editor: &crate::Editor,
) -> Result<DomExportOutput, LexicalError> {
let element = create_dom(node, this, editor.config())?;
let format_type = node.element.get_format_type();
if !format_type.is_empty() {
element.style().set_property("text-align", format_type, "");
}
if let Some(direction) = node.element.get_direction() {
element.set_dir(direction.as_str());
}
if is_nested_list_node(this) {
return Ok(DomExportOutput {
element: Some(element),
after: Some(Box::new(|container: &DomNode| {
if container.is_element()
&& let Some(prev_sibling) = container.previous_element_sibling()
&& prev_sibling.node_name() == "LI"
{
while let Some(child) = container.first_child() {
prev_sibling.append_child(&child);
}
container.remove();
}
Ok(Some(container.clone()))
})),
..DomExportOutput::default()
});
}
Ok(DomExportOutput::element(element))
}
fn class_names_of(value: Option<&Value>) -> Vec<String> {
value
.and_then(Value::as_str)
.map(|v| normalize_class_names(&[v]))
.unwrap_or_default()
}
fn set_list_item_theme_class_names(
dom: &DomNode,
theme: &Object,
node: &ListItemNode,
this: &NodeRef,
) {
let Some(list_theme) = theme.get("list").filter(|t| {
!matches!(t, Value::Undefined | Value::Null | Value::Bool(false))
&& t.as_str() != Some("")
}) else {
return;
};
let list_item_class_name = list_theme.get("listitem");
let nested_list_item_class_name = list_theme.get("nested").and_then(|n| n.get("listitem"));
let parent = this.get_parent();
let is_check_list = parent
.as_ref()
.is_some_and(|p| p.get_list_type() == Some(ListType::Check));
let checked = node.checked == Some(true);
let is_nested = this.get_children().iter().any(is_list_node);
let mut classes_to_remove = class_names_of(list_theme.get("listitemChecked"));
classes_to_remove.extend(class_names_of(list_theme.get("listitemUnchecked")));
classes_to_remove.extend(class_names_of(nested_list_item_class_name));
if !classes_to_remove.is_empty() {
dom.class_list().remove(&classes_to_remove);
}
let mut classes_to_add = class_names_of(list_item_class_name);
if is_check_list {
let key = if checked {
"listitemChecked"
} else {
"listitemUnchecked"
};
classes_to_add.extend(class_names_of(list_theme.get(key)));
}
if is_nested {
classes_to_add.extend(class_names_of(nested_list_item_class_name));
}
if !classes_to_add.is_empty() {
dom.class_list().add(&classes_to_add);
}
}
fn update_list_item_checked(dom: &DomNode, node: &ListItemNode, this: &NodeRef) {
let is_checkbox = this
.get_parent()
.is_some_and(|p| p.get_list_type() == Some(ListType::Check))
&& !this.get_first_child().is_some_and(|c| is_list_node(&c));
if !is_checkbox {
dom.remove_attribute("role");
dom.remove_attribute("tabIndex");
dom.remove_attribute("aria-checked");
} else {
dom.set_attribute("role", "checkbox");
dom.set_attribute("tabIndex", "-1");
dom.set_attribute(
"aria-checked",
if node.checked == Some(true) {
"true"
} else {
"false"
},
);
}
}
pub(crate) fn import_dom() -> crate::lexical_dom::DomConversionMap {
vec![(
"li".to_owned(),
crate::lexical_dom::importer(0, convert_list_item_element),
)]
}
fn convert_list_item_element(
dom_node: &DomNode,
) -> Result<Option<DomConversionOutput>, LexicalError> {
if dom_node.class_list().contains("task-list-item") {
for child in dom_node.children() {
if child.tag_name() == "INPUT" {
return convert_checkbox_input(&child);
}
}
}
if dom_node.class_list().contains("joplin-checkbox") {
for child in dom_node.children() {
let grandchildren = child.children();
if child.class_list().contains("checkbox-wrapper")
&& grandchildren
.first()
.is_some_and(|c| c.tag_name() == "INPUT")
{
return convert_checkbox_input(&grandchildren[0]);
}
}
}
let checked = match dom_node.get_attribute("aria-checked").as_deref() {
Some("true") => Some(true),
Some("false") => Some(false),
_ => None,
};
let node = create_list_item_node(checked);
set_format_from_dom(&node, dom_node);
set_direction_from_dom(&node, dom_node);
Ok(Some(with_format_from_children(node)))
}
fn convert_checkbox_input(
dom_node: &DomNode,
) -> Result<Option<DomConversionOutput>, LexicalError> {
if dom_node.get_attribute("type").as_deref() != Some("checkbox") {
return Ok(Some(DomConversionOutput::node(None)));
}
let node = create_list_item_node(Some(dom_node.has_attribute("checked")));
Ok(Some(with_format_from_children(node)))
}
fn with_format_from_children(node: NodeRef) -> DomConversionOutput {
let list_item_node = node.clone();
DomConversionOutput {
node: DomConversionNode::One(node),
after: Some(Box::new(move |children: Vec<NodeRef>| {
if let [first_child] = children.as_slice()
&& first_child.get_latest().is::<ParagraphNode>()
&& list_item_node.element_data().get_format_type().is_empty()
{
let format_type = first_child.element_data().get_format_type();
if !format_type.is_empty() {
list_item_node.set_element_format(format_type);
return Ok(first_child.get_children());
}
}
Ok(children)
})),
..DomConversionOutput::default()
}
}
}