liwe 0.13.0

IWE core library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use liwe::query::block::{BlockPredicate, IntoBlockPredicate};

pub fn any() -> BlockPredicate {
    BlockPredicate::empty()
}

pub fn text(text: &str) -> BlockPredicate {
    any().text(text)
}

pub fn text_eq(text: &str) -> BlockPredicate {
    any().text_eq(text)
}

pub fn matches(pattern: &str) -> BlockPredicate {
    any().matches(pattern)
}

pub fn within(scope: BlockPredicate) -> BlockPredicate {
    any().within(scope)
}

pub fn within_section(title: &str) -> BlockPredicate {
    any().within_section(title)
}

pub fn contains(pred: BlockPredicate) -> BlockPredicate {
    any().contains(pred)
}

pub fn section(root: impl IntoBlockPredicate) -> BlockPredicate {
    any().section(root)
}

pub fn sections() -> BlockPredicate {
    section(any())
}

pub fn quote(inner: BlockPredicate) -> BlockPredicate {
    any().quote(inner)
}

pub fn quotes() -> BlockPredicate {
    quote(any())
}

pub fn list(inner: BlockPredicate) -> BlockPredicate {
    any().list(inner)
}

pub fn lists() -> BlockPredicate {
    list(any())
}

pub fn header(arg: impl IntoBlockPredicate) -> BlockPredicate {
    any().header(arg)
}

pub fn headers() -> BlockPredicate {
    header(any())
}

pub fn paragraph(arg: impl IntoBlockPredicate) -> BlockPredicate {
    any().paragraph(arg)
}

pub fn paragraphs() -> BlockPredicate {
    paragraph(any())
}

pub fn item(arg: impl IntoBlockPredicate) -> BlockPredicate {
    any().item(arg)
}

pub fn items() -> BlockPredicate {
    item(any())
}

pub fn code(arg: impl IntoBlockPredicate) -> BlockPredicate {
    any().code(arg)
}

pub fn code_blocks() -> BlockPredicate {
    code(any())
}

pub fn table(arg: impl IntoBlockPredicate) -> BlockPredicate {
    any().table(arg)
}

pub fn tables() -> BlockPredicate {
    table(any())
}

pub fn reference(inner: BlockPredicate) -> BlockPredicate {
    any().reference(inner)
}

pub fn refs() -> BlockPredicate {
    reference(any())
}

pub fn hr(inner: BlockPredicate) -> BlockPredicate {
    any().hr(inner)
}

pub fn rules() -> BlockPredicate {
    hr(any())
}

pub fn references(key: &str) -> BlockPredicate {
    any().references(key)
}

pub fn and(preds: Vec<BlockPredicate>) -> BlockPredicate {
    any().and(preds)
}

pub fn or(preds: Vec<BlockPredicate>) -> BlockPredicate {
    any().or(preds)
}

pub fn nor(preds: Vec<BlockPredicate>) -> BlockPredicate {
    any().nor(preds)
}