vxml_pipeline/core

Core desugarer and pipeline types, errors, warnings, and VXML utilities.

Types

ContextualVXMLCondition

pub type ContextualVXMLCondition =
  fn(
    vxml.VXML,
    List(vxml.VXML),
    List(vxml.VXML),
    List(vxml.VXML),
    List(vxml.VXML),
  ) -> Bool

Desugarer

</>

One named VXML -> VXML transformation step.

pub type Desugarer {
  Desugarer(
    name: String,
    stringified_param: option.Option(String),
    stringified_outside: option.Option(String),
    transform: fn(vxml.VXML) -> Result(
      #(vxml.VXML, List(DesugaringWarning)),
      DesugaringError,
    ),
  )
}

Constructors

Desugarer(
  name: String,
  stringified_param: option.Option(String),
  stringified_outside: option.Option(String),
  transform: fn(vxml.VXML) -> Result(
    #(vxml.VXML, List(DesugaringWarning)),
    DesugaringError,
  ),
)

DesugarerTransform

</>

pub type DesugarerTransform =
  fn(vxml.VXML) -> Result(
    #(vxml.VXML, List(DesugaringWarning)),
    DesugaringError,
  )

DesugaringError

</>

pub type DesugaringError {
  DesugaringError(blame: blame.Blame, message: String)
}

Constructors

DesugaringError(blame: blame.Blame, message: String)

DesugaringWarning

</>

pub type DesugaringWarning {
  DesugaringWarning(blame: blame.Blame, message: String)
}

Constructors

DesugaringWarning(blame: blame.Blame, message: String)

LatexDelimiterPair

</>

pub type LatexDelimiterPair {
  DoubleDollar
  SingleDollar
  BackslashParenthesis
  BackslashSquareBracket
  BeginEndAlign
  BeginEndAlignStar
  BeginEndEnvironment(name: String)
}

Constructors

```
DoubleDollar
```
```
SingleDollar
```
```
BackslashParenthesis
```
```
BackslashSquareBracket
```
```
BeginEndAlign
```
```
BeginEndAlignStar
```
```
BeginEndEnvironment(name: String)
```

LatexDelimiterSingleton

</>

pub type LatexDelimiterSingleton {
  DoubleDollarSingleton
  SingleDollarSingleton
  BackslashOpeningParenthesis
  BackslashClosingParenthesis
  BackslashOpeningSquareBracket
  BackslashClosingSquareBracket
  BeginAlign
  EndAlign
  BeginAlignStar
  EndAlignStar
  BeginEnvironment(name: String)
  EndEnvironment(name: String)
}

Constructors

```
DoubleDollarSingleton
```
```
SingleDollarSingleton
```
```
BackslashOpeningParenthesis
```
```
BackslashClosingParenthesis
```
```
BackslashOpeningSquareBracket
```
```
BackslashClosingSquareBracket
```
```
BeginAlign
```
```
EndAlign
```
```
BeginAlignStar
```
```
EndAlignStar
```
```
BeginEnvironment(name: String)
```
```
EndEnvironment(name: String)
```

Pipeline

</>

The ordered VXML -> VXML transformation stage, not the full render loop.

pub type Pipeline =
  List(Desugarer)

SelectorError

</>

pub type SelectorError {
  EmptyTag
  InvalidTag
  InvalidKey
}

Constructors

```
EmptyTag
```
```
InvalidTag
```
```
InvalidKey
```

Values

aggregate_on_first

</>

pub fn aggregate_on_first(
  l: List(#(a, b)),
) -> dict.Dict(a, List(b))

append_if_not_present

</>

pub fn append_if_not_present(items: List(a), item: a) -> List(a)

assert_drop_last

</>

pub fn assert_drop_last(z: List(a)) -> List(a)

assert_drop_prefix

</>

pub fn assert_drop_prefix(s: String, prefix: String) -> String

assert_split_style

</>

pub fn assert_split_style(
  style: String,
) -> List(#(String, String))

attrs_append_classes

</>

pub fn attrs_append_classes(
  attrs: List(vxml.Attr),
  blame: blame.Blame,
  classes: String,
) -> List(vxml.Attr)

attrs_delete

</>

pub fn attrs_delete(
  attrs: List(vxml.Attr),
  key: String,
) -> List(vxml.Attr)

attrs_extract_first

</>

pub fn attrs_extract_first(
  attrs: List(vxml.Attr),
  key: String,
) -> #(option.Option(vxml.Attr), List(vxml.Attr))

attrs_extract_key_occurrences

</>

pub fn attrs_extract_key_occurrences(
  attrs: List(vxml.Attr),
  key: String,
) -> #(List(vxml.Attr), List(vxml.Attr))

attrs_extract_key_val

</>

pub fn attrs_extract_key_val(
  attrs: List(vxml.Attr),
  key: String,
  val: String,
) -> #(List(vxml.Attr), List(vxml.Attr))

attrs_extract_unique_key_or_none

</>

pub fn attrs_extract_unique_key_or_none(
  attrs: List(vxml.Attr),
  key: String,
) -> Result(
  #(option.Option(vxml.Attr), List(vxml.Attr)),
  DesugaringError,
)

attrs_first_with_key

</>

pub fn attrs_first_with_key(
  attrs: List(vxml.Attr),
  key: String,
) -> option.Option(vxml.Attr)

attrs_have_class

</>

pub fn attrs_have_class(
  attrs: List(vxml.Attr),
  class: String,
) -> Bool

attrs_have_key

</>

pub fn attrs_have_key(
  attrs: List(vxml.Attr),
  key: String,
) -> Bool

attrs_have_key_val

</>

pub fn attrs_have_key_val(
  attrs: List(vxml.Attr),
  key: String,
  val: String,
) -> Bool

attrs_merge_prepend_styles

</>

pub fn attrs_merge_prepend_styles(
  attrs: List(vxml.Attr),
  blame: blame.Blame,
  styles: String,
) -> List(vxml.Attr)

attrs_merge_styles

</>

pub fn attrs_merge_styles(
  attrs: List(vxml.Attr),
  blame: blame.Blame,
  styles: String,
) -> List(vxml.Attr)

attrs_replace_val

</>

pub fn attrs_replace_val(
  attrs: List(vxml.Attr),
  from: String,
  to: String,
) -> List(vxml.Attr)

attrs_set

</>

pub fn attrs_set(
  attrs: List(vxml.Attr),
  blame: blame.Blame,
  key: String,
  val: String,
) -> List(vxml.Attr)

attrs_unique_key_or_none

</>

pub fn attrs_unique_key_or_none(
  attrs: List(vxml.Attr),
  key: String,
) -> Result(option.Option(vxml.Attr), DesugaringError)

attrs_val_first_with_key

</>

pub fn attrs_val_first_with_key(
  attrs: List(vxml.Attr),
  key: String,
) -> option.Option(String)

attrs_val_first_with_key_expected

</>

pub fn attrs_val_first_with_key_expected(
  attrs: List(vxml.Attr),
  key: String,
  blame: blame.Blame,
) -> Result(String, DesugaringError)

attrs_val_of_unique_key

</>

pub fn attrs_val_of_unique_key(
  attrs: List(vxml.Attr),
  key: String,
  blame: blame.Blame,
) -> Result(String, DesugaringError)

attrs_with_key

</>

pub fn attrs_with_key(
  attrs: List(vxml.Attr),
  key: String,
) -> List(vxml.Attr)

break_out_first_word

</>

pub fn break_out_first_word(input: String) -> #(String, String)

“word” == “non-whitespace” == empty string if string starts with whitespace

returns: -> #(before_first_space, everything_afterwards)

compose_style

</>

pub fn compose_style(keyvals: List(#(String, String))) -> String

delete

</>

pub fn delete(items: List(a), item: a) -> #(Bool, List(a))

delete_singleton_empty_lines_in_list

</>

pub fn delete_singleton_empty_lines_in_list(
  nodes: List(vxml.VXML),
) -> List(vxml.VXML)

descendant_lines

</>

pub fn descendant_lines(v: vxml.VXML) -> List(vxml.Line)

descendant_text_contains

</>

pub fn descendant_text_contains(v: vxml.VXML, s: String) -> Bool

descendant_text_does_not_contain

</>

pub fn descendant_text_does_not_contain(
  vxml: vxml.VXML,
  s: String,
) -> Bool

descendants_with_class

</>

pub fn descendants_with_class(
  vxml: vxml.VXML,
  class: String,
) -> List(vxml.VXML)

descendants_with_tag

</>

pub fn descendants_with_tag(
  vxml: vxml.VXML,
  tag: String,
) -> List(vxml.VXML)

dict_from_list

</>

pub fn dict_from_list(
  l: List(#(a, b)),
) -> Result(dict.Dict(a, b), DesugaringError)

drop_ending_slash

</>

pub fn drop_ending_slash(path: String) -> String

drop_last

</>

pub fn drop_last(z: List(a)) -> List(a)

drop_prefix

</>

pub fn drop_prefix(s: String, prefix: String) -> String

drop_suffix

</>

pub fn drop_suffix(s: String, suffix: String) -> String

ensure_prefix

</>

pub fn ensure_prefix(s: String, prefix: String) -> String

ensure_suffix

</>

pub fn ensure_suffix(s: String, suffix: String) -> String

expand_selector_shorthand

</>

pub fn expand_selector_shorthand(
  shorthand: String,
) -> Result(vxml.VXML, SelectorError)

extract_first_word_from_t_node_if_t

</>

pub fn extract_first_word_from_t_node_if_t(
  vxml: vxml.VXML,
) -> #(option.Option(vxml.VXML), vxml.VXML)

“word” == “non-whitespace” == empty string if node starts with whitespace

returns -> #( Option(new T(..) containing first word), node leftover with word taken out, )

extract_last_word_from_t_node_if_t

</>

pub fn extract_last_word_from_t_node_if_t(
  vxml: vxml.VXML,
) -> #(vxml.VXML, option.Option(vxml.VXML))

“word” == “non-whitespace” == empty string if node ends with whitespace

returns -> #( node leftover with last word taken out, Option(new T(..) containing last word), )

extract_trim_end

</>

pub fn extract_trim_end(content: String) -> #(String, String)

extract_trim_start

</>

pub fn extract_trim_start(content: String) -> #(String, String)

filter_descendants

</>

pub fn filter_descendants(
  vxml: vxml.VXML,
  condition: fn(vxml.VXML) -> Bool,
) -> List(vxml.VXML)

find_replace_if_t

</>

pub fn find_replace_if_t(
  node: vxml.VXML,
  from: String,
  to: String,
) -> vxml.VXML

find_replace_if_t__batch

</>

pub fn find_replace_if_t__batch(
  node: vxml.VXML,
  pairs: List(#(String, String)),
) -> vxml.VXML

first_line_ends_with

</>

pub fn first_line_ends_with(
  lines: List(vxml.Line),
  s: String,
) -> Bool

first_line_starts_with

</>

pub fn first_line_starts_with(
  lines: List(vxml.Line),
  s: String,
) -> Bool

first_with_tag

</>

pub fn first_with_tag(
  nodes: List(vxml.VXML),
  tag: String,
) -> option.Option(vxml.VXML)

from_tag

</>

pub fn from_tag(
  blame: blame.Blame,
  tag: String,
) -> Result(vxml.VXML, DesugaringError)

get_contained

</>

pub fn get_contained(
  from: List(a),
  in: List(a),
) -> option.Option(a)

get_duplicate

</>

pub fn get_duplicate(list: List(a)) -> option.Option(a)

html_info_shorthand_to_attrs

</>

pub fn html_info_shorthand_to_attrs(
  blame: blame.Blame,
  info: String,
) -> Result(
  #(
    option.Option(vxml.Attr),
    option.Option(vxml.Attr),
    option.Option(vxml.Attr),
    option.Option(vxml.Attr),
  ),
  String,
)

insert_before_first

</>

pub fn insert_before_first(
  list: List(a),
  elt: a,
  condition: fn(a) -> Bool,
) -> List(a)

insert_child_before_first_in_list

</>

pub fn insert_child_before_first_in_list(
  nodes: List(vxml.VXML),
  child: vxml.VXML,
  before: String,
) -> List(vxml.VXML)

insert_in_list_pair_as_dict

</>

pub fn insert_in_list_pair_as_dict(
  list_pairs: List(#(a, b)),
  item: #(a, b),
) -> List(#(a, b))

invalid_tag

</>

pub fn invalid_tag(tag: String) -> Bool

is_t

</>

pub fn is_t(node: vxml.VXML) -> Bool

is_t_and_text_contains

</>

pub fn is_t_and_text_contains(
  vxml: vxml.VXML,
  content: String,
) -> Bool

is_t_or_is_one_of

</>

pub fn is_t_or_is_one_of(
  node: vxml.VXML,
  tags: List(String),
) -> Bool

is_v

</>

pub fn is_v(node: vxml.VXML) -> Bool

is_v_and_has_attr_with_key

</>

pub fn is_v_and_has_attr_with_key(
  vxml: vxml.VXML,
  key: String,
) -> Bool

is_v_and_has_class

</>

pub fn is_v_and_has_class(vxml: vxml.VXML, class: String) -> Bool

is_v_and_tag_equals

</>

pub fn is_v_and_tag_equals(vxml: vxml.VXML, tag: String) -> Bool

is_v_and_tag_is_not_one_of

</>

pub fn is_v_and_tag_is_not_one_of(
  vxml: vxml.VXML,
  tags: List(String),
) -> Bool

is_v_and_tag_is_one_of

</>

pub fn is_v_and_tag_is_one_of(
  vxml: vxml.VXML,
  tags: List(String),
) -> Bool

is_v_and_tag_not_equals

</>

pub fn is_v_and_tag_not_equals(
  vxml: vxml.VXML,
  tag: String,
) -> Bool

kebab_case_to_camel_case

</>

pub fn kebab_case_to_camel_case(input: String) -> String

keys

</>

pub fn keys(attrs: List(vxml.Attr)) -> List(String)

last_to_first_concatenation

</>

pub fn last_to_first_concatenation(
  vxmls: List(vxml.VXML),
) -> List(vxml.VXML)

last_to_first_concatenation_in_list_list_lines

</>

pub fn last_to_first_concatenation_in_list_list_lines(
  l: List(List(vxml.Line)),
) -> List(vxml.Line)

last_to_first_concatenation_in_list_list_of_lines_where_all_but_last_list_are_already_reversed

</>

pub fn last_to_first_concatenation_in_list_list_of_lines_where_all_but_last_list_are_already_reversed(
  list_of_lists: List(List(vxml.Line)),
) -> List(vxml.Line)

latex_inline_delimiters

</>

pub fn latex_inline_delimiters() -> List(LatexDelimiterPair)

latex_strippable_delimiter_pairs

</>

pub fn latex_strippable_delimiter_pairs() -> List(
  LatexDelimiterPair,
)

latex_strippable_display_delimiters

</>

pub fn latex_strippable_display_delimiters() -> List(
  LatexDelimiterPair,
)

lines_are_whitespace

</>

pub fn lines_are_whitespace(lines: List(vxml.Line)) -> Bool

lines_contain

</>

pub fn lines_contain(lines: List(vxml.Line), s: String) -> Bool

lines_first_blame

</>

pub fn lines_first_blame(lines: List(vxml.Line)) -> blame.Blame

lines_map_content

</>

pub fn lines_map_content(
  lines: List(vxml.Line),
  m: fn(String) -> String,
) -> List(vxml.Line)

lines_remove_starting_empty_lines

</>

pub fn lines_remove_starting_empty_lines(
  l: List(vxml.Line),
) -> List(vxml.Line)

lines_total_chars

</>

pub fn lines_total_chars(lines: List(vxml.Line)) -> Int

lines_trim_start

</>

pub fn lines_trim_start(
  lines: List(vxml.Line),
) -> List(vxml.Line)

list_param_stringifier

</>

pub fn list_param_stringifier(param: List(p)) -> String

list_set

</>

pub fn list_set(
  items: List(a),
  index: Int,
  element: a,
) -> List(a)

list_string_stringifier

</>

pub fn list_string_stringifier(param: List(String)) -> String

merge_attrs

</>

pub fn merge_attrs(attrs: List(vxml.Attr)) -> List(vxml.Attr)

merge_classes

</>

pub fn merge_classes(a: String, b: String) -> String

merge_styles

</>

pub fn merge_styles(a: String, b: String) -> String

normalize_spaces

</>

pub fn normalize_spaces(s: String) -> String

not_contains

</>

pub fn not_contains(list: List(a), element: a) -> Bool

on_t_on_v

</>

pub fn on_t_on_v(
  node: vxml.VXML,
  f1: fn(blame.Blame, List(vxml.Line)) -> c,
  f2: fn(blame.Blame, String, List(vxml.Attr), List(vxml.VXML)) -> c,
) -> c

opening_and_closing_delimiter_strings

</>

pub fn opening_and_closing_delimiter_strings(
  delimiters: List(LatexDelimiterPair),
) -> #(List(String), List(String))

opening_and_closing_singletons_for_pair

</>

pub fn opening_and_closing_singletons_for_pair(
  pair: LatexDelimiterPair,
) -> #(LatexDelimiterSingleton, LatexDelimiterSingleton)

opening_and_closing_string_for_pair

</>

pub fn opening_and_closing_string_for_pair(
  pair: LatexDelimiterPair,
) -> #(String, String)

optional_style_extract_unique_key_or_none

</>

pub fn optional_style_extract_unique_key_or_none(
  style_attr: option.Option(vxml.Attr),
  key: String,
) -> Result(
  #(option.Option(String), option.Option(vxml.Attr)),
  DesugaringError,
)

pair_2nd

</>

pub fn pair_2nd(t: #(a, b)) -> b

plain_concatenation_in_list

</>

pub fn plain_concatenation_in_list(
  nodes: List(vxml.VXML),
) -> List(vxml.VXML)

pour

</>

pub fn pour(from: List(a), into: List(a)) -> List(a)

dumps the contents of ‘from’ “upside-down” into ‘into’, so that the first element of ‘from’ ends up buried inside the resulting list, while the last element of ‘from’ ends up surfaced as the first element of the result

pour_before_first

</>

pub fn pour_before_first(
  list: List(a),
  to_pour: List(a),
  condition: fn(a) -> Bool,
) -> List(a)

pour_before_first_in_list

</>

pub fn pour_before_first_in_list(
  nodes: List(vxml.VXML),
  to_insert: List(vxml.VXML),
  before: String,
) -> List(vxml.VXML)

pour_but_last

</>

pub fn pour_but_last(
  from: List(a),
  into: List(a),
) -> #(List(a), a)

prefix_partition

</>

pub fn prefix_partition(
  list: List(a),
  condition: fn(a) -> Bool,
) -> #(List(a), List(a))

quad_drop_3rd

</>

pub fn quad_drop_3rd(t: #(a, b, c, d)) -> #(a, b, d)

quad_drop_4th

</>

pub fn quad_drop_4th(t: #(a, b, c, d)) -> #(a, b, c)

quad_to_pair

</>

pub fn quad_to_pair(t: #(a, b, c, d)) -> #(a, #(b, c, d))

quad_to_pair_pair

</>

pub fn quad_to_pair_pair(t: #(a, b, c, d)) -> #(#(a, b), #(c, d))

quads_to_pair_pairs

</>

pub fn quads_to_pair_pairs(
  l: List(#(a, b, c, d)),
) -> List(#(#(a, b), #(c, d)))

quads_to_pairs

</>

pub fn quads_to_pairs(
  l: List(#(a, b, c, d)),
) -> List(#(a, #(b, c, d)))

read_singleton

</>

pub fn read_singleton(z: List(a)) -> Result(a, SingletonError)

remove_class

</>

pub fn remove_class(classes: String, class: String) -> String

remove_in_class_attr

</>

pub fn remove_in_class_attr(
  attrs: List(vxml.Attr),
  to_be_removed: String,
) -> List(vxml.Attr)

replace_attr_val

</>

pub fn replace_attr_val(
  attr: vxml.Attr,
  from: String,
  to: String,
) -> vxml.Attr

reversed_lines_trim_end

</>

pub fn reversed_lines_trim_end(
  lines: List(vxml.Line),
) -> List(vxml.Line)

split_lines

</>

pub fn split_lines(
  lines: List(vxml.Line),
  splitter: String,
) -> List(List(vxml.Line))

string_pair_to_attr

</>

pub fn string_pair_to_attr(
  pair: #(String, String),
  blame: blame.Blame,
) -> vxml.Attr

string_pairs_to_attrs

</>

pub fn string_pairs_to_attrs(
  pairs: List(#(String, String)),
  blame: blame.Blame,
) -> List(vxml.Attr)

style_extract_unique_key_or_none

</>

pub fn style_extract_unique_key_or_none(
  style: String,
  key: String,
  blame: blame.Blame,
) -> Result(#(option.Option(String), String), DesugaringError)

substitute_in_class_attr

</>

pub fn substitute_in_class_attr(
  attrs: List(vxml.Attr),
  from: String,
  to: String,
) -> List(vxml.Attr)

suffix_partition

</>

pub fn suffix_partition(
  l: List(a),
  condition: fn(a) -> Bool,
) -> #(List(a), List(a))

supplement_in_class_attr

</>

pub fn supplement_in_class_attr(
  attrs: List(vxml.Attr),
  if_this_is_there: String,
  then_add: String,
) -> List(vxml.Attr)

t_end_insert_line

</>

pub fn t_end_insert_line(
  vxml: vxml.VXML,
  line: vxml.Line,
) -> vxml.VXML

t_end_insert_text

</>

pub fn t_end_insert_text(
  vxml: vxml.VXML,
  text: String,
) -> vxml.VXML

t_extract_ending_spaces

</>

pub fn t_extract_ending_spaces(
  node: vxml.VXML,
) -> #(option.Option(vxml.VXML), vxml.VXML)

t_extract_starting_spaces

</>

pub fn t_extract_starting_spaces(
  node: vxml.VXML,
) -> #(option.Option(vxml.VXML), vxml.VXML)

t_find_replace

</>

pub fn t_find_replace(
  node: vxml.VXML,
  from: String,
  to: String,
) -> vxml.VXML

t_find_replace__batch

</>

pub fn t_find_replace__batch(
  vxml: vxml.VXML,
  pairs: List(#(String, String)),
) -> vxml.VXML

t_map

</>

pub fn t_map(
  vxmls: List(vxml.VXML),
  f: fn(vxml.VXML) -> vxml.VXML,
) -> List(vxml.VXML)

t_remove_ending_empty_lines

</>

pub fn t_remove_ending_empty_lines(
  vxml: vxml.VXML,
) -> option.Option(vxml.VXML)

t_remove_starting_empty_lines

</>

pub fn t_remove_starting_empty_lines(
  vxml: vxml.VXML,
) -> option.Option(vxml.VXML)

t_start_insert_line

</>

pub fn t_start_insert_line(
  vxml: vxml.VXML,
  line: vxml.Line,
) -> vxml.VXML

t_start_insert_text

</>

pub fn t_start_insert_text(
  vxml: vxml.VXML,
  text: String,
) -> vxml.VXML

t_t_last_to_first_concatenation

</>

pub fn t_t_last_to_first_concatenation(
  node1: vxml.VXML,
  node2: vxml.VXML,
) -> vxml.VXML

t_trim_end

</>

pub fn t_trim_end(node: vxml.VXML) -> option.Option(vxml.VXML)

t_trim_start

</>

pub fn t_trim_start(node: vxml.VXML) -> option.Option(vxml.VXML)

total_chars

</>

pub fn total_chars(vxml: vxml.VXML) -> Int

trim_ending_spaces_except_last_line

</>

pub fn trim_ending_spaces_except_last_line(
  vxml: vxml.VXML,
) -> vxml.VXML

trim_starting_spaces_except_first_line

</>

pub fn trim_starting_spaces_except_first_line(
  vxml: vxml.VXML,
) -> vxml.VXML

triple_3rd

</>

pub fn triple_3rd(t: #(a, b, c)) -> c

triple_drop_2nd

</>

pub fn triple_drop_2nd(t: #(a, b, c)) -> #(a, c)

triple_drop_3rd

</>

pub fn triple_drop_3rd(t: #(a, b, c)) -> #(a, b)

triple_to_pair

</>

pub fn triple_to_pair(t: #(a, b, c)) -> #(a, #(b, c))

triples_to_aggregated_dict

</>

pub fn triples_to_aggregated_dict(
  l: List(#(a, b, c)),
) -> dict.Dict(a, List(#(b, c)))

triples_to_dict

</>

pub fn triples_to_dict(
  l: List(#(a, b, c)),
) -> dict.Dict(a, #(b, c))

triples_to_pairs

</>

pub fn triples_to_pairs(
  l: List(#(a, b, c)),
) -> List(#(a, #(b, c)))

try_map_fold

</>

pub fn try_map_fold(
  over items: List(q),
  from state: a,
  with f: fn(a, q) -> Result(#(q, a), c),
) -> Result(#(List(q), a), c)

use_list_pair_as_dict

</>

pub fn use_list_pair_as_dict(
  list_pairs: List(#(a, b)),
  key: a,
) -> Result(b, Nil)

v_append_classes

</>

pub fn v_append_classes(
  node: vxml.VXML,
  classes: String,
) -> vxml.VXML

v_append_classes_if

</>

pub fn v_append_classes_if(
  node: vxml.VXML,
  classes: String,
  condition: fn(vxml.VXML) -> Bool,
) -> vxml.VXML

v_assert_pop_attr

</>

pub fn v_assert_pop_attr(
  vxml: vxml.VXML,
  key: String,
) -> #(vxml.VXML, vxml.Attr)

v_assert_pop_attr_val

</>

pub fn v_assert_pop_attr_val(
  vxml: vxml.VXML,
  key: String,
) -> #(vxml.VXML, String)

v_attrs_constructor

</>

pub fn v_attrs_constructor(
  blame: blame.Blame,
  tag: String,
  attrs: List(#(String, String)),
) -> vxml.VXML

v_attrs_with_key

</>

pub fn v_attrs_with_key(
  vxml: vxml.VXML,
  key: String,
) -> List(vxml.Attr)

v_children_with_class

</>

pub fn v_children_with_class(
  vxml: vxml.VXML,
  class: String,
) -> List(vxml.VXML)

v_children_with_tag

</>

pub fn v_children_with_tag(
  vxml: vxml.VXML,
  tag: String,
) -> List(vxml.VXML)

v_children_with_tags

</>

pub fn v_children_with_tags(
  vxml: vxml.VXML,
  tags: List(String),
) -> List(vxml.VXML)

v_end_insert_line

</>

pub fn v_end_insert_line(
  vxml: vxml.VXML,
  line: vxml.Line,
) -> vxml.VXML

v_end_insert_text

</>

pub fn v_end_insert_text(
  vxml: vxml.VXML,
  text: String,
) -> vxml.VXML

v_extract_children

</>

pub fn v_extract_children(
  vxml: vxml.VXML,
  condition: fn(vxml.VXML) -> Bool,
) -> #(vxml.VXML, List(vxml.VXML))

v_extract_ending_spaces

</>

pub fn v_extract_ending_spaces(
  node: vxml.VXML,
) -> #(option.Option(vxml.VXML), vxml.VXML)

v_extract_starting_spaces

</>

pub fn v_extract_starting_spaces(
  node: vxml.VXML,
) -> #(option.Option(vxml.VXML), vxml.VXML)

v_filter_children

</>

pub fn v_filter_children(
  vxml: vxml.VXML,
  condition: fn(vxml.VXML) -> Bool,
) -> List(vxml.VXML)

v_first_attr_with_key

</>

pub fn v_first_attr_with_key(
  vxml: vxml.VXML,
  key: String,
) -> option.Option(vxml.Attr)

v_first_child_with_tag

</>

pub fn v_first_child_with_tag(
  vxml: vxml.VXML,
  tag: String,
) -> option.Option(vxml.VXML)

v_get_children

</>

pub fn v_get_children(vxml: vxml.VXML) -> List(vxml.VXML)

v_get_tag

</>

pub fn v_get_tag(vxml: vxml.VXML) -> String

v_has_attr_with_key

</>

pub fn v_has_attr_with_key(vxml: vxml.VXML, key: String) -> Bool

v_has_class

</>

pub fn v_has_class(vxml: vxml.VXML, class: String) -> Bool

v_has_key_val

</>

pub fn v_has_key_val(
  vxml: vxml.VXML,
  key: String,
  val: String,
) -> Bool

v_map

</>

pub fn v_map(
  vxmls: List(vxml.VXML),
  f: fn(vxml.VXML) -> vxml.VXML,
) -> List(vxml.VXML)

v_pour_before_first

</>

pub fn v_pour_before_first(
  vxml: vxml.VXML,
  to_insert: List(vxml.VXML),
  before: String,
) -> vxml.VXML

v_prepend_attr

</>

pub fn v_prepend_attr(
  vxml: vxml.VXML,
  attr: vxml.Attr,
) -> vxml.VXML

v_prepend_child

</>

pub fn v_prepend_child(
  vxml: vxml.VXML,
  child: vxml.VXML,
) -> vxml.VXML

v_prepend_unique_key_attr

</>

pub fn v_prepend_unique_key_attr(
  vxml: vxml.VXML,
  attr: vxml.Attr,
) -> Result(vxml.VXML, Nil)

v_remove_ending_empty_lines

</>

pub fn v_remove_ending_empty_lines(node: vxml.VXML) -> vxml.VXML

v_remove_starting_empty_lines

</>

pub fn v_remove_starting_empty_lines(
  node: vxml.VXML,
) -> vxml.VXML

v_replace_children_with

</>

pub fn v_replace_children_with(
  vxml: vxml.VXML,
  children: List(vxml.VXML),
) -> vxml.VXML

v_set_attr

</>

pub fn v_set_attr(
  vxml: vxml.VXML,
  blame: blame.Blame,
  key: String,
  val: String,
) -> vxml.VXML

v_set_tag

</>

pub fn v_set_tag(v: vxml.VXML, tag: String) -> vxml.VXML

v_start_insert_line

</>

pub fn v_start_insert_line(
  vxml: vxml.VXML,
  line: vxml.Line,
) -> vxml.VXML

v_start_insert_text

</>

pub fn v_start_insert_text(
  vxml: vxml.VXML,
  text: String,
) -> vxml.VXML

v_tag_is_one_of

</>

pub fn v_tag_is_one_of(
  vxml: vxml.VXML,
  tags: List(String),
) -> Bool

v_trim_end

</>

pub fn v_trim_end(node: vxml.VXML) -> vxml.VXML

v_trim_start

</>

pub fn v_trim_start(node: vxml.VXML) -> vxml.VXML

v_unique_child

</>

pub fn v_unique_child(
  vxml: vxml.VXML,
  tag: String,
) -> Result(vxml.VXML, DesugaringError)

v_unique_child_with_singleton_error

</>

pub fn v_unique_child_with_singleton_error(
  vxml: vxml.VXML,
  tag: String,
) -> Result(vxml.VXML, SingletonError)

v_val_of_first_attr_with_key

</>

pub fn v_val_of_first_attr_with_key(
  vxml: vxml.VXML,
  key: String,
) -> option.Option(String)

valid_tag

</>

pub fn valid_tag(tag: String) -> Bool

validate_unique_keys

</>

pub fn validate_unique_keys(
  l: List(#(a, b)),
) -> Result(List(#(a, b)), DesugaringError)

vxml_digest

</>

pub fn vxml_digest(vxml: vxml.VXML) -> String

with_default

</>

pub fn with_default(
  o: option.Option(a),
  default: a,
) -> option.Option(a)