def __init__(self):

self.web_forms_data = []

def _add(self, name: str, value: str = ""):

if value:

self.web_forms_data.append(f"{name}={value}")

else:

self.web_forms_data.append(name)

def _get_line_by_index(self, index: int) -> str:

if not self.web_forms_data or index >= len(self.web_forms_data):

return ""

if index < 0:

index = len(self.web_forms_data) + index

if index < 0 or index >= len(self.web_forms_data):

return ""

return self.web_forms_data[index]

def _update_line_by_index(self, index: int, name: str, value: str = ""):

if not self.web_forms_data or index >= len(self.web_forms_data):

return

if index < 0:

index = len(self.web_forms_data) + index

if index < 0 or index >= len(self.web_forms_data):

return

if value:

self.web_forms_data[index] = f"{name}={value}"

else:

self.web_forms_data[index] = name

# For Extension

def add_line(self, name: str, value: str):

self._add(name, value)

# Add

def add_id(self, input_place: str, element_id: str):

self._add(f"ai{input_place}", element_id)

def add_name(self, input_place: str, name: str):

self._add(f"an{input_place}", name)

def add_value(self, input_place: str, value: str):

self._add(f"av{input_place}", value)

def add_class(self, input_place: str, class_name: str):

self._add(f"ac{input_place}", class_name)

def add_style(self, input_place: str, style: str):

self._add(f"as{input_place}", style)

def add_style_property(self, input_place: str, name: str, value: str):

self._add(f"as{input_place}", f"{name}:{value}")

def add_option_tag(self, input_place: str, text: str, value: str, selected: bool = False):

self._add(f"ao{input_place}", f"{value}|{text}" + ("|1" if selected else ""))

def add_checkbox_tag(self, input_place: str, text: str, value: str, checked: bool = False):

self._add(f"ak{input_place}", f"{value}|{text}" + ("|1" if checked else ""))

def add_title(self, input_place: str, title: str):

self._add(f"al{input_place}", title)

def add_label(self, input_place: str, label: str):

self._add(f"aA{input_place}", label)

def add_text(self, input_place: str, text: str):

self._add(f"at{input_place}", text.replace('\n', '$[ln];'))

def add_text_to_up(self, input_place: str, text: str):

self._add(f"pt{input_place}", text.replace('\n', '$[ln];'))

def add_attribute(self, input_place: str, attribute: str, value: str = "", splitter: str = '\0'):

splitter_str = splitter if splitter != '\0' else ""

self._add(f"aa{input_place}", f"{attribute}|{splitter_str}" + (f"|{value}" if value else ""))

def add_tag(self, input_place: str, tag_name: str, element_id: str = ""):

self._add(f"nt{input_place}", tag_name + (f"|{element_id}" if element_id else ""))

def add_tag_to_up(self, input_place: str, tag_name: str, element_id: str = ""):

self._add(f"ut{input_place}", tag_name + (f"|{element_id}" if element_id else ""))

def add_tag_before(self, input_place: str, tag_name: str, element_id: str = ""):

self._add(f"bt{input_place}", tag_name + (f"|{element_id}" if element_id else ""))

def add_tag_after(self, input_place: str, tag_name: str, element_id: str = ""):

self._add(f"ft{input_place}", tag_name + (f"|{element_id}" if element_id else ""))

def add_hidden(self, input_place: str, value: str, element_id: str = ""):

self._add(f"ah{input_place}", value + (f"|{element_id}" if element_id else ""))

# Set

def set_id(self, input_place: str, element_id: str):

self._add(f"si{input_place}", element_id)

def set_name(self, input_place: str, name: str):

self._add(f"sn{input_place}", name)

def set_value(self, input_place: str, value: str):

self._add(f"sv{input_place}", value)

def set_class(self, input_place: str, class_name: str):

self._add(f"sc{input_place}", class_name)

def set_style(self, input_place: str, style: str):

self._add(f"ss{input_place}", style)

def set_style_property(self, input_place: str, name: str, value: str):

self._add(f"ss{input_place}", f"{name}:{value}")

def set_option_tag(self, input_place: str, text: str, value: str, selected: bool = False):

self._add(f"so{input_place}", f"{value}|{text}" + ("|1" if selected else ""))

def set_checked(self, input_place: str, checked: bool = False):

self._add(f"sk{input_place}", "1" if checked else "0")

def set_checkbox_tag(self, input_place: str, text: str, value: str, checked: bool = False):

self._add(f"sk{input_place}", f"{value}|{text}" + ("|1" if checked else ""))

def set_title(self, input_place: str, title: str):

self._add(f"sl{input_place}", title)

def set_label(self, input_place: str, label: str):

self._add(f"sA{input_place}", label)

def set_text(self, input_place: str, text: str):

self._add(f"st{input_place}", text.replace('\n', '$[ln];'))

def set_attribute(self, input_place: str, attribute: str, value: str = ""):

self._add(f"sa{input_place}", f"{attribute}" + (f"|{value}" if value else ""))

def set_width(self, input_place: str, width: Union[str, int]):

if isinstance(width, int):

width = f"{width}px"

self._add(f"sw{input_place}", width)

def set_height(self, input_place: str, height: Union[str, int]):

if isinstance(height, int):

height = f"{height}px"

self._add(f"sh{input_place}", height)

def set_background_color(self, input_place: str, color: str):

self._add(f"bc{input_place}", color)

def set_text_color(self, input_place: str, color: str):

self._add(f"tc{input_place}", color)

def set_font_name(self, input_place: str, name: str):

self._add(f"fn{input_place}", name)

def set_font_size(self, input_place: str, size: Union[str, int]):

if isinstance(size, int):

size = f"{size}px"

self._add(f"fs{input_place}", size)

def set_font_bold(self, input_place: str, bold: bool):

self._add(f"fb{input_place}", "1" if bold else "0")

def set_visible(self, input_place: str, visible: bool):

self._add(f"vi{input_place}", "1" if visible else "0")

def set_text_align(self, input_place: str, align: str):

self._add(f"ta{input_place}", align)

def set_read_only(self, input_place: str, read_only: bool):

self._add(f"sr{input_place}", "1" if read_only else "0")

def set_disabled(self, input_place: str, disabled: bool):

self._add(f"sd{input_place}", "1" if disabled else "0")

def set_focus(self, input_place: str, focus: bool):

self._add(f"sf{input_place}", "1" if focus else "0")

def set_min_length(self, input_place: str, length: int):

self._add(f"mn{input_place}", str(length))

def set_max_length(self, input_place: str, length: int):

self._add(f"mx{input_place}", str(length))

def set_selected_value(self, input_place: str, value: str):

self._add(f"ts{input_place}", value)

def set_selected_index(self, input_place: str, index: int):

self._add(f"ti{input_place}", str(index))

def set_checked_value(self, input_place: str, value: str, selected: bool):

self._add(f"ks{input_place}", f"{value}|{'1' if selected else '0'}")

def set_checked_index(self, input_place: str, index: int, selected: bool):

self._add(f"ki{input_place}", f"{index}|{'1' if selected else '0'}")

# Insert

def insert_id(self, input_place: str, element_id: str):

self._add(f"ii{input_place}", element_id)

def insert_name(self, input_place: str, name: str):

self._add(f"in{input_place}", name)

def insert_value(self, input_place: str, value: str):

self._add(f"iv{input_place}", value)

def insert_class(self, input_place: str, class_name: str):

self._add(f"ic{input_place}", class_name)

def insert_style(self, input_place: str, style: str):

self._add(f"is{input_place}", style)

def insert_style_property(self, input_place: str, name: str, value: str):

self._add(f"is{input_place}", f"{name}:{value}")

def insert_option_tag(self, input_place: str, text: str, value: str, selected: bool = False):

self._add(f"io{input_place}", f"{value}|{text}" + ("|1" if selected else ""))

def insert_checkbox_tag(self, input_place: str, text: str, value: str, checked: bool = False):

self._add(f"ik{input_place}", f"{value}|{text}" + ("|1" if checked else ""))

def insert_title(self, input_place: str, title: str):

self._add(f"il{input_place}", title)

def insert_label(self, input_place: str, label: str):

self._add(f"iA{input_place}", label)

def insert_text(self, input_place: str, text: str):

self._add(f"it{input_place}", text.replace('\n', '$[ln];'))

def insert_attribute(self, input_place: str, attribute: str, value: str = "", splitter: str = '\0'):

splitter_str = splitter if splitter != '\0' else ""

self._add(f"ia{input_place}", f"{attribute}|{splitter_str}" + (f"|{value}" if value else ""))

# Delete

def delete_id(self, input_place: str):

self._add(f"di{input_place}")

def delete_name(self, input_place: str):

self._add(f"dn{input_place}")

def delete_value(self, input_place: str):

self._add(f"dv{input_place}")

def delete_class(self, input_place: str, class_name: str):

self._add(f"dc{input_place}", class_name)

def delete_style(self, input_place: str, style_name: str):

self._add(f"ds{input_place}", style_name)

def delete_option_tag(self, input_place: str, value: str):

self._add(f"do{input_place}", value)

def delete_all_option_tag(self, input_place: str):

self._add(f"do{input_place}", "*")

def delete_checkbox_tag(self, input_place: str, value: str):

self._add(f"dk{input_place}", value)

def delete_all_checkbox_tag(self, input_place: str):

self._add(f"dk{input_place}", "*")

def delete_title(self, input_place: str):

self._add(f"dl{input_place}")

def delete_label(self, input_place: str):

self._add(f"dA{input_place}")

def delete_text(self, input_place: str):

self._add(f"dt{input_place}")

def delete_attribute(self, input_place: str, attribute: str):

self._add(f"da{input_place}", attribute)

def delete(self, input_place: str):

self._add(f"de{input_place}")

def delete_parent(self, input_place: str):

self._add(f"dp{input_place}")

# Tag

def swap_tag(self, input_place: str, output_place: str):

self._add(f"sp{input_place}", output_place)

def set_reflection(self, input_place: str, tag: str):

self._add(f"sR{input_place}", tag)

def set_reflection_by_output_place(self, input_place: str, output_place: str):

self._add(f"iR{input_place}", output_place)

# Browser

def change_url(self, url: str):

self._add("cu", url)

def set_head_title(self, title: str):

self._add("ht", title)

def clipboard_write_text(self, text: str):

self._add("nw", text)

def scroll_to(self, x: int, y: int):

self._add("ws", f"{x}|{y}")

def history_go(self, steps: int):

self._add("wg", str(steps))

def reload_page(self):

self._add("lr")

def redirect(self, path: str):

self._add("lh", path)

# Increase

def increase_min_length(self, input_place: str, value: int):

self._add(f"+n{input_place}", str(value))

def increase_max_length(self, input_place: str, value: int):

self._add(f"+x{input_place}", str(value))

def increase_font_size(self, input_place: str, value: int):

self._add(f"+f{input_place}", str(value))

def increase_width(self, input_place: str, value: int):

self._add(f"+w{input_place}", str(value))

def increase_height(self, input_place: str, value: int):

self._add(f"+h{input_place}", str(value))

def increase_value(self, input_place: str, value: int):

self._add(f"+v{input_place}", str(value))

# Decrease

def decrease_min_length(self, input_place: str, value: int):

self._add(f"-n{input_place}", str(value))

def decrease_max_length(self, input_place: str, value: int):

self._add(f"-x{input_place}", str(value))

def decrease_font_size(self, input_place: str, value: int):

self._add(f"-f{input_place}", str(value))

def decrease_width(self, input_place: str, value: int):

self._add(f"-w{input_place}", str(value))

def decrease_height(self, input_place: str, value: int):

self._add(f"-h{input_place}", str(value))

def decrease_value(self, input_place: str, value: int):

self._add(f"-v{input_place}", str(value))

# Event

def trigger_event(self, input_place: str, html_event_listener: str, constructor_name: Optional[str] = None):

value = html_event_listener

if constructor_name:

value += f"|{constructor_name}"

self._add(f"TE{input_place}", value)

def set_post_event(self, input_place: str, html_event: str):

self._add(f"Ep{input_place}", html_event)

def set_post_event_view(self, input_place: str, html_event: str):

self._add(f"Ep{input_place}", f"{html_event}|+")

def set_post_event_to(self, input_place: str, html_event: str, output_place: str):

self._add(f"Ep{input_place}", f"{html_event}|{output_place}")

def set_post_event_listener(self, input_place: str, html_event_listener: str):

self._add(f"EP{input_place}", html_event_listener)

def set_post_event_listener_view(self, input_place: str, html_event_listener: str):

self._add(f"EP{input_place}", f"{html_event_listener}|+")

def set_post_event_listener_to(self, input_place: str, html_event_listener: str, output_place: str):

self._add(f"EP{input_place}", f"{html_event_listener}|{output_place}")

def set_get_event(self, input_place: str, html_event: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"Eg{input_place}", f"{html_event}|{path_str}|{output_place}")

else:

self._add(f"Eg{input_place}", f"{html_event}|{path_str}")

def set_get_event_listener(self, input_place: str, html_event_listener: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"EG{input_place}", f"{html_event_listener}|{path_str}|{output_place}")

else:

self._add(f"EG{input_place}", f"{html_event_listener}|{path_str}")

def set_patch_event(self, input_place: str, html_event: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"Ea{input_place}", f"{html_event}|{path_str}|{output_place}")

else:

self._add(f"Ea{input_place}", f"{html_event}|{path_str}")

def set_patch_event_listener(self, input_place: str, html_event_listener: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"EA{input_place}", f"{html_event_listener}|{path_str}|{output_place}")

else:

self._add(f"EA{input_place}", f"{html_event_listener}|{path_str}")

def set_delete_event(self, input_place: str, html_event: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"El{input_place}", f"{html_event}|{path_str}|{output_place}")

else:

self._add(f"El{input_place}", f"{html_event}|{path_str}")

def set_delete_event_listener(self, input_place: str, html_event_listener: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"EL{input_place}", f"{html_event_listener}|{path_str}|{output_place}")

else:

self._add(f"EL{input_place}", f"{html_event_listener}|{path_str}")

def set_options_event(self, input_place: str, html_event: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"Eo{input_place}", f"{html_event}|{path_str}|{output_place}")

else:

self._add(f"Eo{input_place}", f"{html_event}|{path_str}")

def set_options_event_listener(self, input_place: str, html_event_listener: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"EO{input_place}", f"{html_event_listener}|{path_str}|{output_place}")

else:

self._add(f"EO{input_place}", f"{html_event_listener}|{path_str}")

def set_trace_event(self, input_place: str, html_event: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"Er{input_place}", f"{html_event}|{path_str}|{output_place}")

else:

self._add(f"Er{input_place}", f"{html_event}|{path_str}")

def set_trace_event_listener(self, input_place: str, html_event_listener: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"ER{input_place}", f"{html_event_listener}|{path_str}|{output_place}")

else:

self._add(f"ER{input_place}", f"{html_event_listener}|{path_str}")

def set_connect_event(self, input_place: str, html_event: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"Ec{input_place}", f"{html_event}|{path_str}|{output_place}")

else:

self._add(f"Ec{input_place}", f"{html_event}|{path_str}")

def set_connect_event_listener(self, input_place: str, html_event_listener: str, path: Optional[str] = None, output_place: Optional[str] = None):

path_str = path if path else "#"

if output_place:

self._add(f"EC{input_place}", f"{html_event_listener}|{path_str}|{output_place}")

else:

self._add(f"EC{input_place}", f"{html_event_listener}|{path_str}")

def set_head_event(self, input_place: str, html_event: str, path: Optional[str] = None):

path_str = path if path else "#"

self._add(f"Eh{input_place}", f"{html_event}|{path_str}")

def set_head_event_listener(self, input_place: str, html_event_listener: str, path: Optional[str] = None):

path_str = path if path else "#"

self._add(f"EH{input_place}", f"{html_event_listener}|{path_str}")

def set_tag_event(self, input_place: str, html_event: str, output_place: str):

self._add(f"Et{input_place}", f"{html_event}|{output_place}")

def set_tag_event_listener(self, input_place: str, html_event_listener: str, output_place: str):

self._add(f"ET{input_place}", f"{html_event_listener}|{output_place}")

def set_comment_event(self, input_place: str, html_event: str, index: Optional[Union[str, int]] = None, output_place: Optional[str] = None):

index_str = str(index) if index is not None else ""

output_str = output_place if output_place else ""

self._add(f"Eb{input_place}", f"{html_event}|{index_str}|{output_str}")

def set_comment_event_listener(self, input_place: str, html_event_listener: str, index: Optional[Union[str, int]] = None, output_place: Optional[str] = None):

index_str = str(index) if index is not None else ""

output_str = output_place if output_place else ""

self._add(f"EB{input_place}", f"{html_event_listener}|{index_str}|{output_str}")

def set_wasm_event(self, input_place: str, html_event: str, wasm_language: str, wasm_url: str,

method_name: str, args: Optional[List[str]] = None, output_place: Optional[str] = None):

args_join = ",".join(args) if args else ""

output_str = output_place if output_place else ""

self._add(f"Ey{input_place}", f"{html_event}|{wasm_language}|{wasm_url}|{method_name}|{args_join}|{output_str}")

def set_wasm_event_listener(self, input_place: str, html_event_listener: str, wasm_language: str, wasm_url: str,

method_name: str, args: Optional[List[str]] = None, output_place: Optional[str] = None):

args_join = ",".join(args) if args else ""

output_str = output_place if output_place else ""

self._add(f"EY{input_place}", f"{html_event_listener}|{wasm_language}|{wasm_url}|{method_name}|{args_join}|{output_str}")

def set_websocket_event(self, input_place: str, html_event: str, path: str):

self._add(f"Ew{input_place}", f"{html_event}|{path}")

def set_websocket_event_listener(self, input_place: str, html_event_listener: str, path: str):

self._add(f"EW{input_place}", f"{html_event_listener}|{path}")

def set_sse_event(self, input_place: str, html_event: str, path: str, should_reconnect: bool = True,

reconnect_try_timeout: int = 3000, output_place: Optional[str] = None):

value = f"{html_event}|{path}|{'1' if should_reconnect else '0'}|{reconnect_try_timeout}"

if output_place:

value += f"|{output_place}"

self._add(f"Ee{input_place}", value)

def set_sse_event_listener(self, input_place: str, html_event_listener: str, path: str, should_reconnect: bool = True,

reconnect_try_timeout: int = 3000, output_place: Optional[str] = None):

value = f"{html_event_listener}|{path}|{'1' if should_reconnect else '0'}|{reconnect_try_timeout}"

if output_place:

value += f"|{output_place}"

self._add(f"EE{input_place}", value)

def set_front_event(self, input_place: str, html_event: str, module_path: str,

args: Optional[List[str]] = None, output_place: Optional[str] = None):

args_join = "|" + "|".join(args) if args else ""

output_str = output_place if output_place else ""

self._add(f"Ej{input_place}", f"{html_event}|{module_path}|{output_str}{args_join}")

def set_front_event_listener(self, input_place: str, html_event_listener: str, module_path: str,

args: Optional[List[str]] = None, output_place: Optional[str] = None):

args_join = "|" + "|".join(args) if args else ""

output_str = output_place if output_place else ""

self._add(f"EJ{input_place}", f"{html_event_listener}|{module_path}|{output_str}{args_join}")

def set_send_event(self, input_place: str, html_event: str, data: str, path: Optional[str] = None,

method: str = "POST", is_multi_part: bool = False, content_type: str = "text/plain",

output_place: Optional[str] = None):

path_str = path if path else "#"

data_safe = data.replace('\n', '$[ln];').replace('"', '$[dq];').replace("'", '$[sq];')

output_str = output_place if output_place else ""

self._add(f"En{input_place}", f"{html_event}|{data_safe}|{path_str}|{method}|{'1' if is_multi_part else '0'}|{content_type}|{output_str}")

def set_send_event_listener(self, input_place: str, html_event_listener: str, data: str, path: Optional[str] = None,

method: str = "POST", is_multi_part: bool = False, content_type: str = "text/plain",

output_place: Optional[str] = None):

path_str = path if path else "#"

data_safe = data.replace('\n', '$[ln];')

output_str = output_place if output_place else ""

self._add(f"EN{input_place}", f"{html_event_listener}|{data_safe}|{path_str}|{method}|{'1' if is_multi_part else '0'}|{content_type}|{output_str}")

def set_master_pages_event(self, input_place: str, html_event: str, output_place: Optional[str] = None):

value = html_event

if output_place:

value += f"|{output_place}"

self._add(f"Eu{input_place}", value)

def set_master_pages_event_listener(self, input_place: str, html_event_listener: str, output_place: Optional[str] = None):

value = html_event_listener

if output_place:

value += f"|{output_place}"

self._add(f"EU{input_place}", value)

def set_prevent_default_event(self, input_place: str, html_event: str):

self._add(f"Ed{input_place}", html_event)

def set_prevent_default_event_listener(self, input_place: str, html_event_listener: str):

self._add(f"ED{input_place}", html_event_listener)

def set_stop_propagation_event(self, input_place: str, html_event: str):

self._add(f"Es{input_place}", html_event)

def set_stop_propagation_event_listener(self, input_place: str, html_event_listener: str):

self._add(f"ES{input_place}", html_event_listener)

def set_method_event(self, input_place: str, html_event: str, method_name: str, args: Optional[List[str]] = None):

args_join = "|" + "|".join(args) if args else ""

self._add(f"Em{input_place}", f"{html_event}|{method_name}{args_join}")

def set_method_event_listener(self, input_place: str, html_event_listener: str, method_name: str, args: Optional[List[str]] = None):

args_join = "|" + "|".join(args) if args else ""

self._add(f"EM{input_place}", f"{html_event_listener}|{method_name}{args_join}")

def set_module_method_event(self, input_place: str, html_event: str, method_name: str, args: Optional[List[str]] = None):

args_join = "|" + "|".join(args) if args else ""

self._add(f"Ex{input_place}", f"{html_event}|{method_name}{args_join}")

def set_module_method_event_listener(self, input_place: str, html_event_listener: str, method_name: str, args: Optional[List[str]] = None):

args_join = "|" + "|".join(args) if args else ""

self._add(f"EX{input_place}", f"{html_event_listener}|{method_name}{args_join}")

def assign_confirm_event(self, input_place: str, html_event: str, text: str = "Are you sure you want to proceed?",

type_: str = "none", title: str = "Confirm", ok_text: str = "OK", cancel_text: str = "Cancel"):

text_str = "" if text == "Are you sure you want to proceed?" else text

type_str = "" if type_ == "none" else type_

title_str = "" if title == "Confirm" else title

ok_str = "" if ok_text == "OK" else ok_text

cancel_str = "" if cancel_text == "Cancel" else cancel_text

self._add(f"Ef{input_place}", f"{html_event}|{text_str}|{type_str}|{title_str}|{ok_str}|{cancel_str}")

def remove_post_event(self, input_place: str, html_event: str):

self._add(f"Rp{input_place}", html_event)

def remove_post_event_listener(self, input_place: str, html_event_listener: str):

self._add(f"RP{input_place}", html_event_listener)

# Note: Many more remove methods would be added here following the same pattern

# For brevity, I'm showing a few examples

def remove_get_event(self, input_place: str, html_event: str):

self._add(f"Rg{input_place}", html_event)

def remove_get_event_listener(self, input_place: str, html_event_listener: str):

self._add(f"RG{input_place}", html_event_listener)

# Custom Event

def create_custom_dom_event(self, input_place: str, event_name: str, watch: str, key: str,

compare: str, value: str, range_: str, immediate: bool = False, delay: int = 0):

self._add(f"eC{input_place}", f"{event_name}|{watch}|{key}|{compare}|{value}|{range_}|{'1' if immediate else '0'}|{delay}")

def enable_scroll_bottom_event(self, enable: bool = True):

self._add("eb", "1" if enable else "0")

def enable_reached_element_event(self, input_place: str, once: bool, enable: bool = True):

self._add(f"er{input_place}", f"{'1' if once else '0'}|{'1' if enable else '0'}")

# Module

def load_module(self, module_path: str, methods: List[str]):

methods_str = "|" + "|".join(methods) if methods else ""

self._add("Ml", f"{module_path}{methods_str}")

def unload_module(self, module_path: str):

self._add("Mu", module_path)

def delete_module_method(self, method_name: str):

self._add("Md", method_name)

# Unit Testing

def assert_equal(self, input_place: str, tag: str):

self._add(f"At{input_place}", tag.replace('\n', '$[ln];'))

def assert_equal_by_output_place(self, input_place: str, output_place: str):

self._add(f"Ao{input_place}", output_place)

# Service Worker

def service_worker_register(self, path: Optional[str] = None, scope_path: Optional[str] = None):

self._add("wR", f"{path if path else ''}|{scope_path if scope_path else ''}")

def service_worker_pre_cache_static(self, path_list: List[str]):

self._add("wp", "|".join(path_list))

def service_worker_dynamic_cache(self, path: str, seconds: int = 0):

value = path

if seconds > 0:

value += f"|{seconds}"

self._add("wc", value)

def service_worker_delete_dynamic_cache(self, path: Optional[str] = None):