4163427832

Build Type

push

github

Committed by Martin Middel

Commit Message

Use delimited CUT instead of manual

Run Details

4896 of 5693 branches covered (86.0%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 2 files covered. (100.0%)

1 existing line in 1 file now uncovered.

10529 of 11168 relevant lines covered (94.28%)

32462.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.36

/src/parsing/literalParser.ts

import {
        cut,
        delimited,
        filter,
        followed,
        map,
        not,
        optional,
        or,
        Parser,
        peek,
        preceded,
        star,
        then,
} from 'prsc';
import { IAST } from './astHelper';
import { ncName } from './nameParser';
import { alias, precededMultiple, regex, then3, wrapArray } from './parsingFunctions';
import * as tokens from './tokens';
import {
        char,
        explicitWhitespace,
        whitespace,
        whitespaceCharacter,
        whitespacePlus,
} from './whitespaceParser';

// Declare this type to prevent renames down the road
export declare type QNameAST = [{ prefix: string | null; URI: string | null }, string];

export const assertAdjacentOpeningTerminal: Parser<string> = peek(
        or([tokens.BRACE_OPEN, tokens.DOUBLE_QUOTE, tokens.SINGLE_QUOTE, whitespaceCharacter])
);

export const forwardAxis: Parser<string> = map(
        or([
                tokens.CHILD_AXIS,
                tokens.DESCENDANT_AXIS,
                tokens.ATTRIBUTE_AXIS,
                tokens.SELF_AXIS,
                tokens.DESCENDANT_OR_SELF_AXIS,
                tokens.FOLLOWING_SIBLING_AXIS,
                tokens.FOLLOWING_AXIS,
        ]),
        (x: string) => x.substring(0, x.length - 2)
);

export const reverseAxis: Parser<string> = map(
        or([
                tokens.PARENT_AXIS,
                tokens.ANCESTOR_AXIS,
                tokens.PRECEDING_SIBLING_AXIS,
                tokens.PRECEDING_AXIS,
                tokens.ANCESTOR_OR_SELF_AXIS,
        ]),
        (x: string) => x.substring(0, x.length - 2)
);

export const predefinedEntityRef: Parser<string> = then3(
        tokens.AMPERSAND,
        or([tokens.LT, tokens.GT, tokens.AMP, tokens.QUOT, tokens.APOS]),
        tokens.SEMICOLON,
        (a, b, c) => a + b + c
);

export const charRef: Parser<string> = or([
        then3(tokens.CHAR_REF_HEX, regex(/[0-9a-fA-F]+/), tokens.SEMICOLON, (a, b, c) => a + b + c),
        then3(tokens.CHAR_REF, regex(/[0-9]+/), tokens.SEMICOLON, (a, b, c) => a + b + c),
]);

export const escapeQuot: Parser<string> = alias([tokens.DOUBLE_QUOTE_DOUBLE], '"');
export const escapeApos: Parser<string> = alias([tokens.SINGLE_QUOTE_DOUBLE], "'");

export const commentTest: Parser<IAST> = wrapArray(alias([tokens.COMMENT_TEST], 'commentTest'));
export const textTest: Parser<IAST> = wrapArray(alias([tokens.TEXT_TEST], 'textTest'));
export const namespaceNodeTest: Parser<IAST> = wrapArray(
        alias([tokens.NAMESPACE_NODE_TEST], 'namespaceTest')
);
export const anyKindTest: Parser<IAST> = wrapArray(alias([tokens.ANY_KIND_TEST], 'anyKindTest'));

const digits: Parser<string> = regex(/[0-9]+/);

const doubleLiteral: Parser<IAST> = then(
        or([
                then(tokens.DOT, digits, (dot, digitsParsed) => dot + digitsParsed),
                then(
                        digits,
                        optional(preceded(tokens.DOT, regex(/[0-9]*/))),
                        (a, b) => a + (b !== null ? '.' + b : '')
                ),
        ]),
        then3(
                or([tokens.E_LOWER, tokens.E_UPPER]),
                optional(or([tokens.PLUS, tokens.MINUS])),
                digits,
                (e, expSign, expDigits) => e + (expSign ? expSign : '') + expDigits
        ),
        (base, exponent) => ['doubleConstantExpr', ['value', base + exponent]]
);

const decimalLiteral: Parser<IAST> = or([
        map(preceded(tokens.DOT, digits), (x) => ['decimalConstantExpr', ['value', '.' + x]]),
        then(followed(digits, tokens.DOT), optional(digits), (first, second) => [
                'decimalConstantExpr',
                ['value', first + '.' + (second !== null ? second : '')],
        ]),
]);

export const integerLiteral: Parser<IAST> = map(
        digits,
        (x) => ['integerConstantExpr', ['value', x]] as IAST
);

export const numericLiteral: Parser<IAST> = followed(
        or([doubleLiteral, decimalLiteral, integerLiteral]),
        peek(not(regex(/[a-zA-Z]/), ['no alphabetical characters after numeric literal']))
);

export const contextItemExpr: Parser<IAST> = map(
        followed(
                tokens.DOT,
                peek(not(tokens.DOT, ['context item should not be followed by another .']))
        ),
        (_) => ['contextItemExpr']
);

export const reservedFunctionNames = or([
        tokens.ARRAY,
        tokens.ATTRIBUTE,
        tokens.COMMENT,
        tokens.DOCUMENT_NODE,
        tokens.ELEMENT,
        tokens.EMPTY_SEQUENCE,
        tokens.FUNCTION,
        tokens.IF,
        tokens.ITEM,
        tokens.MAP,
        tokens.NAMESPACE_NODE,
        tokens.NODE,
        tokens.PROCESSING_INSTRUCTION,
        tokens.SCHEMA_ATTRIBUTE,
        tokens.SCHEMA_ELEMENT,
        tokens.SWITCH,
        tokens.TEXT,
        tokens.TYPESWITCH,
]);

export const argumentPlaceholder: Parser<IAST> = wrapArray(
        alias([tokens.QUESTION_MARK], 'argumentPlaceholder')
);

export const occurrenceIndicator: Parser<string> = or([
        tokens.QUESTION_MARK,
        tokens.ASTERIX,
        tokens.PLUS,
]);

export const elementContentChar = preceded(
        peek(not(regex(/[{}<&]/), ['elementContentChar cannot be {, }, <, or &'])),
        char
);

export const cdataSection: Parser<IAST> = map(
        delimited(
                tokens.CDATA_OPEN,
                star(
                        preceded(
                                peek(not(tokens.CDATA_CLOSE, ['CDataSection content may not contain "]]>"'])),
                                char
                        )
                ),
                tokens.CDATA_CLOSE,
                true
        ),
        (contents) => ['CDataSection', contents.join('')]
);

export const quotAttrValueContentChar: Parser<string> = preceded(
        peek(not(regex(/[\"{}<&]/), ['quotAttrValueContentChar cannot be ", {, }, <, or &'])),
        char
);

export const aposAttrValueContentChar: Parser<string> = preceded(
        peek(not(regex(/[\'{}<&]/), ["aposAttrValueContentChar cannot be ', {, }, <, or &"])),
        char
);

export const dirCommentContents: Parser<string> = map(
        star(
                or([
                        preceded(peek(not(tokens.MINUS, [])), char),
                        map(
                                precededMultiple(
                                        [tokens.MINUS, peek(not(tokens.MINUS, [])) as Parser<string>],
                                        char
                                ),
                                (x) => '-' + x
                        ),
                ])
        ),
        (x) => x.join('')
);

export const dirCommentConstructor: Parser<IAST> = map(
        delimited(tokens.DIR_COMMENT_OPEN, dirCommentContents, tokens.DIR_COMMENT_CLOSE, true),
        (x) => ['computedCommentConstructor', ['argExpr', ['stringConstantExpr', ['value', x]]]]
);

// Note: we deviate from the grammar in the XQuery spec here. Processing instruction targets must
// _always_ be a NCName
const piTarget: Parser<string> = filter(
        ncName,
        (target: string) => {
                return target.toLowerCase() !== 'xml';
        },
        ['A processing instruction target cannot be "xml"']
);

const dirPiContents: Parser<string> = map(
        star(preceded(peek(not(tokens.DIR_PI_CLOSE, [])), char)),
        (x) => x.join('')
);

export const dirPiConstructor: Parser<IAST> = then(
        preceded(tokens.DIR_PI_OPEN, cut(piTarget)),
        cut(followed(optional(preceded(explicitWhitespace, dirPiContents)), tokens.DIR_PI_CLOSE)),
        (target, contents) => [
                'computedPIConstructor',
                ['piTarget', target],
                ['piValueExpr', ['stringConstantExpr', ['value', contents]]],
        ]
);

export const locationPathAbbreviation: Parser<IAST> = map(tokens.DOUBLE_SLASH, (_) => [
        'stepExpr',
        ['xpathAxis', 'descendant-or-self'],
        ['anyKindTest'],
]);

export const validationMode: Parser<string> = or([tokens.LAX, tokens.STRICT]);

export const pragmaContents: Parser<string> = map(
        star(followed(char, peek(not(tokens.PRAGMA_END, ["Pragma contents should not contain '#)'"])))),
        (x) => x.join('')
);

export const valueCompare: Parser<string> = map(
        followed(
                or([tokens.EQ, tokens.NE, tokens.LT, tokens.LE, tokens.GT, tokens.GE]),
                assertAdjacentOpeningTerminal
        ),
        (x) => x + 'Op'
);

export const nodeCompare: Parser<string> = or([
        followed(alias([tokens.IS], 'isOp'), assertAdjacentOpeningTerminal),
        alias([tokens.LESS_THAN_DOUBLE], 'nodeBeforeOp'),
        alias([tokens.GREATER_THAN_DOUBLE], 'nodeAfterOp'),
]);

export const generalCompare: Parser<string> = or([
        alias([tokens.EQUALS], 'equalOp'),
        alias([tokens.NOT_EQUALS], 'notEqualOp'),
        alias([tokens.LESS_THAN_EQUALS], 'lessThanOrEqualOp'),
        alias([tokens.LESS_THAN], 'lessThanOp'),
        alias([tokens.GREATER_THAN_EQUALS], 'greaterThanOrEqualOp'),
        alias([tokens.GREATER_THAN], 'greaterThanOp'),
]);

export const compatibilityAnnotation: Parser<IAST> = map(tokens.UPDATING, (_) => [
        'annotation',
        ['annotationName', 'updating'],
]);

export const separator: Parser<string> = tokens.SEMICOLON;

const preserveMode: Parser<string> = or([tokens.PRESERVE, tokens.NO_PRESERVE]);

const inheritMode: Parser<string> = or([tokens.INHERIT, tokens.NO_INHERIT]);

export const decimalFormatPropertyName: Parser<string> = or([
        tokens.DECIMAL_SEPARATOR,
        tokens.GROUPING_SEPARATOR,
        tokens.INFINITY,
        tokens.MINUS_SIGN,
        tokens.NAN,
        tokens.PERCENT,
        tokens.PER_MILLE,
        tokens.ZERO_DIGIT,
        tokens.DIGIT,
        tokens.PATTERN_SEPARATOR,
        tokens.EXPONENT_SEPARATOER,
]);

export const boundarySpaceDecl: Parser<IAST> = map(
        precededMultiple(
                [tokens.DECLARE, whitespacePlus, tokens.BOUNDARY_SPACE, whitespacePlus],
                or([tokens.PRESERVE, tokens.STRIP])
        ),
        (x) => ['boundarySpaceDecl', x]
);

export const constructionDecl: Parser<IAST> = map(
        precededMultiple(
                [tokens.DECLARE, whitespacePlus, tokens.CONSTRUCTION, whitespacePlus],
                or([tokens.PRESERVE, tokens.STRIP])
        ),
        (x) => ['constructionDecl', x]
);

export const orderingModeDecl: Parser<IAST> = map(
        precededMultiple(
                [tokens.DECLARE, whitespacePlus, tokens.ORDERING, whitespacePlus],
                or([tokens.ORDERED, tokens.UNORDERED])
        ),
        (x) => ['orderingModeDecl', x]
);

export const emptyOrderDecl: Parser<IAST> = map(
        precededMultiple(
                [
                        tokens.DECLARE,
                        whitespacePlus,
                        tokens.DEFAULT,
                        whitespacePlus,
                        tokens.ORDER,
                        whitespacePlus,
                        tokens.EMPTY,
                        whitespacePlus,
                ],
                or([tokens.GREATEST, tokens.LEAST])
        ),
        (x) => ['emptyOrderDecl', x]
);

export const copyNamespacesDecl: Parser<IAST> = then(
        precededMultiple(
                [tokens.DECLARE, whitespacePlus, tokens.COPY_NAMESPACES, whitespacePlus],
                preserveMode
        ),
        precededMultiple([whitespace, tokens.COMMA, whitespace], inheritMode),
        (preserveModePart, inheritModePart) => [
                'copyNamespacesDecl',
                ['preserveMode', preserveModePart],
                ['inheritMode', inheritModePart],
        ]
);

1	import {	3✔
2	cut,
3	delimited,
4	filter,
5	followed,
6	map,
7	not,
8	optional,
9	or,
10	Parser,
11	peek,
12	preceded,
13	star,
14	then,
15	} from 'prsc';
16	import { IAST } from './astHelper';
17	import { ncName } from './nameParser';	3✔
18	import { alias, precededMultiple, regex, then3, wrapArray } from './parsingFunctions';	3✔
19	import * as tokens from './tokens';	3✔
20	import {	3✔
21	char,
22	explicitWhitespace,
23	whitespace,
24	whitespaceCharacter,
25	whitespacePlus,
26	} from './whitespaceParser';
27
28	// Declare this type to prevent renames down the road
29	export declare type QNameAST = [{ prefix: string \| null; URI: string \| null }, string];
30
31	export const assertAdjacentOpeningTerminal: Parser<string> = peek(	3✔
32	or([tokens.BRACE_OPEN, tokens.DOUBLE_QUOTE, tokens.SINGLE_QUOTE, whitespaceCharacter])
33	);
34
35	export const forwardAxis: Parser<string> = map(	3✔
36	or([
37	tokens.CHILD_AXIS,
38	tokens.DESCENDANT_AXIS,
39	tokens.ATTRIBUTE_AXIS,
40	tokens.SELF_AXIS,
41	tokens.DESCENDANT_OR_SELF_AXIS,
42	tokens.FOLLOWING_SIBLING_AXIS,
43	tokens.FOLLOWING_AXIS,
44	]),
45	(x: string) => x.substring(0, x.length - 2)	1,065✔
46	);
47
48	export const reverseAxis: Parser<string> = map(	3✔
49	or([
50	tokens.PARENT_AXIS,
51	tokens.ANCESTOR_AXIS,
52	tokens.PRECEDING_SIBLING_AXIS,
53	tokens.PRECEDING_AXIS,
54	tokens.ANCESTOR_OR_SELF_AXIS,
55	]),
56	(x: string) => x.substring(0, x.length - 2)	331✔
57	);
58
59	export const predefinedEntityRef: Parser<string> = then3(	3✔
60	tokens.AMPERSAND,
61	or([tokens.LT, tokens.GT, tokens.AMP, tokens.QUOT, tokens.APOS]),
62	tokens.SEMICOLON,
63	(a, b, c) => a + b + c	12✔
64	);
65
66	export const charRef: Parser<string> = or([	3✔
67	then3(tokens.CHAR_REF_HEX, regex(/[0-9a-fA-F]+/), tokens.SEMICOLON, (a, b, c) => a + b + c),	8✔
68	then3(tokens.CHAR_REF, regex(/[0-9]+/), tokens.SEMICOLON, (a, b, c) => a + b + c),	8✔
69	]);
70
71	export const escapeQuot: Parser<string> = alias([tokens.DOUBLE_QUOTE_DOUBLE], '"');	3✔
72	export const escapeApos: Parser<string> = alias([tokens.SINGLE_QUOTE_DOUBLE], "'");	3✔
73
74	export const commentTest: Parser<IAST> = wrapArray(alias([tokens.COMMENT_TEST], 'commentTest'));	3✔
75	export const textTest: Parser<IAST> = wrapArray(alias([tokens.TEXT_TEST], 'textTest'));	3✔
76	export const namespaceNodeTest: Parser<IAST> = wrapArray(	3✔
77	alias([tokens.NAMESPACE_NODE_TEST], 'namespaceTest')
78	);
79	export const anyKindTest: Parser<IAST> = wrapArray(alias([tokens.ANY_KIND_TEST], 'anyKindTest'));	3✔
80
81	const digits: Parser<string> = regex(/[0-9]+/);	3✔
82
83	const doubleLiteral: Parser<IAST> = then(	3✔
84	or([
85	then(tokens.DOT, digits, (dot, digitsParsed) => dot + digitsParsed),	3✔
86	then(
87	digits,
88	optional(preceded(tokens.DOT, regex(/[0-9]*/))),
89	(a, b) => a + (b !== null ? '.' + b : '')	21,186✔
90	),
91	]),
92	then3(
93	or([tokens.E_LOWER, tokens.E_UPPER]),
94	optional(or([tokens.PLUS, tokens.MINUS])),
95	digits,
96	(e, expSign, expDigits) => e + (expSign ? expSign : '') + expDigits	73✔
97	),
98	(base, exponent) => ['doubleConstantExpr', ['value', base + exponent]]	73✔
99	);
100
101	const decimalLiteral: Parser<IAST> = or([	3✔
102	map(preceded(tokens.DOT, digits), (x) => ['decimalConstantExpr', ['value', '.' + x]]),	3✔
103	then(followed(digits, tokens.DOT), optional(digits), (first, second) => [	208✔
104	'decimalConstantExpr',
105	['value', first + '.' + (second !== null ? second : '')],	208!
106	]),
107	]);
108
109	export const integerLiteral: Parser<IAST> = map(	3✔
110	digits,
111	(x) => ['integerConstantExpr', ['value', x]] as IAST	21,042✔
112	);
113
114	export const numericLiteral: Parser<IAST> = followed(	3✔
115	or([doubleLiteral, decimalLiteral, integerLiteral]),
116	peek(not(regex(/[a-zA-Z]/), ['no alphabetical characters after numeric literal']))
117	);
118
119	export const contextItemExpr: Parser<IAST> = map(	3✔
120	followed(
121	tokens.DOT,
122	peek(not(tokens.DOT, ['context item should not be followed by another .']))
123	),
124	(_) => ['contextItemExpr']	599✔
125	);
126
127	export const reservedFunctionNames = or([	3✔
128	tokens.ARRAY,
129	tokens.ATTRIBUTE,
130	tokens.COMMENT,
131	tokens.DOCUMENT_NODE,
132	tokens.ELEMENT,
133	tokens.EMPTY_SEQUENCE,
134	tokens.FUNCTION,
135	tokens.IF,
136	tokens.ITEM,
137	tokens.MAP,
138	tokens.NAMESPACE_NODE,
139	tokens.NODE,
140	tokens.PROCESSING_INSTRUCTION,
141	tokens.SCHEMA_ATTRIBUTE,
142	tokens.SCHEMA_ELEMENT,
143	tokens.SWITCH,
144	tokens.TEXT,
145	tokens.TYPESWITCH,
146	]);
147
148	export const argumentPlaceholder: Parser<IAST> = wrapArray(	3✔
149	alias([tokens.QUESTION_MARK], 'argumentPlaceholder')
150	);
151
152	export const occurrenceIndicator: Parser<string> = or([	3✔
153	tokens.QUESTION_MARK,
154	tokens.ASTERIX,
155	tokens.PLUS,
156	]);
157
158	export const elementContentChar = preceded(	3✔
159	peek(not(regex(/[{}<&]/), ['elementContentChar cannot be {, }, <, or &'])),
160	char
161	);
162
163	export const cdataSection: Parser<IAST> = map(	3✔
164	delimited(
165	tokens.CDATA_OPEN,
166	star(
167	preceded(
168	peek(not(tokens.CDATA_CLOSE, ['CDataSection content may not contain "]]>"'])),
169	char
170	)
171	),
172	tokens.CDATA_CLOSE,
173	true
174	),
175	(contents) => ['CDataSection', contents.join('')]	9✔
176	);
177
178	export const quotAttrValueContentChar: Parser<string> = preceded(	3✔
179	peek(not(regex(/[\"{}<&]/), ['quotAttrValueContentChar cannot be ", {, }, <, or &'])),
180	char
181	);
182
183	export const aposAttrValueContentChar: Parser<string> = preceded(	3✔
184	peek(not(regex(/[\'{}<&]/), ["aposAttrValueContentChar cannot be ', {, }, <, or &"])),
185	char
186	);
187
188	export const dirCommentContents: Parser<string> = map(	3✔
189	star(
190	or([
191	preceded(peek(not(tokens.MINUS, [])), char),
192	map(
193	precededMultiple(
194	[tokens.MINUS, peek(not(tokens.MINUS, [])) as Parser<string>],
195	char
196	),
UNCOV 197	(x) => '-' + x	×
198	),
199	])
200	),
201	(x) => x.join('')	264✔
202	);
203
204	export const dirCommentConstructor: Parser<IAST> = map(	3✔
205	delimited(tokens.DIR_COMMENT_OPEN, dirCommentContents, tokens.DIR_COMMENT_CLOSE, true),
206	(x) => ['computedCommentConstructor', ['argExpr', ['stringConstantExpr', ['value', x]]]]	264✔
207	);
208
209	// Note: we deviate from the grammar in the XQuery spec here. Processing instruction targets must
210	// _always_ be a NCName
211	const piTarget: Parser<string> = filter(	3✔
212	ncName,
213	(target: string) => {
214	return target.toLowerCase() !== 'xml';	15✔
215	},
216	['A processing instruction target cannot be "xml"']
217	);
218
219	const dirPiContents: Parser<string> = map(	3✔
220	star(preceded(peek(not(tokens.DIR_PI_CLOSE, [])), char)),
221	(x) => x.join('')	15✔
222	);
223
224	export const dirPiConstructor: Parser<IAST> = then(	3✔
225	preceded(tokens.DIR_PI_OPEN, cut(piTarget)),
226	cut(followed(optional(preceded(explicitWhitespace, dirPiContents)), tokens.DIR_PI_CLOSE)),
227	(target, contents) => [	15✔
228	'computedPIConstructor',
229	['piTarget', target],
230	['piValueExpr', ['stringConstantExpr', ['value', contents]]],
231	]
232	);
233
234	export const locationPathAbbreviation: Parser<IAST> = map(tokens.DOUBLE_SLASH, (_) => [	498✔
235	'stepExpr',
236	['xpathAxis', 'descendant-or-self'],
237	['anyKindTest'],
238	]);
239
240	export const validationMode: Parser<string> = or([tokens.LAX, tokens.STRICT]);	3✔
241
242	export const pragmaContents: Parser<string> = map(	3✔
243	star(followed(char, peek(not(tokens.PRAGMA_END, ["Pragma contents should not contain '#)'"])))),
244	(x) => x.join('')	×
245	);
246
247	export const valueCompare: Parser<string> = map(	3✔
248	followed(
249	or([tokens.EQ, tokens.NE, tokens.LT, tokens.LE, tokens.GT, tokens.GE]),
250	assertAdjacentOpeningTerminal
251	),
252	(x) => x + 'Op'	426✔
253	);
254
255	export const nodeCompare: Parser<string> = or([	3✔
256	followed(alias([tokens.IS], 'isOp'), assertAdjacentOpeningTerminal),
257	alias([tokens.LESS_THAN_DOUBLE], 'nodeBeforeOp'),
258	alias([tokens.GREATER_THAN_DOUBLE], 'nodeAfterOp'),
259	]);
260
261	export const generalCompare: Parser<string> = or([	3✔
262	alias([tokens.EQUALS], 'equalOp'),
263	alias([tokens.NOT_EQUALS], 'notEqualOp'),
264	alias([tokens.LESS_THAN_EQUALS], 'lessThanOrEqualOp'),
265	alias([tokens.LESS_THAN], 'lessThanOp'),
266	alias([tokens.GREATER_THAN_EQUALS], 'greaterThanOrEqualOp'),
267	alias([tokens.GREATER_THAN], 'greaterThanOp'),
268	]);
269
270	export const compatibilityAnnotation: Parser<IAST> = map(tokens.UPDATING, (_) => [	22✔
271	'annotation',
272	['annotationName', 'updating'],
273	]);
274
275	export const separator: Parser<string> = tokens.SEMICOLON;	3✔
276
277	const preserveMode: Parser<string> = or([tokens.PRESERVE, tokens.NO_PRESERVE]);	3✔
278
279	const inheritMode: Parser<string> = or([tokens.INHERIT, tokens.NO_INHERIT]);	3✔
280
281	export const decimalFormatPropertyName: Parser<string> = or([	3✔
282	tokens.DECIMAL_SEPARATOR,
283	tokens.GROUPING_SEPARATOR,
284	tokens.INFINITY,
285	tokens.MINUS_SIGN,
286	tokens.NAN,
287	tokens.PERCENT,
288	tokens.PER_MILLE,
289	tokens.ZERO_DIGIT,
290	tokens.DIGIT,
291	tokens.PATTERN_SEPARATOR,
292	tokens.EXPONENT_SEPARATOER,
293	]);
294
295	export const boundarySpaceDecl: Parser<IAST> = map(	3✔
296	precededMultiple(
297	[tokens.DECLARE, whitespacePlus, tokens.BOUNDARY_SPACE, whitespacePlus],
298	or([tokens.PRESERVE, tokens.STRIP])
299	),
300	(x) => ['boundarySpaceDecl', x]	×
301	);
302
303	export const constructionDecl: Parser<IAST> = map(	3✔
304	precededMultiple(
305	[tokens.DECLARE, whitespacePlus, tokens.CONSTRUCTION, whitespacePlus],
306	or([tokens.PRESERVE, tokens.STRIP])
307	),
308	(x) => ['constructionDecl', x]	×
309	);
310
311	export const orderingModeDecl: Parser<IAST> = map(	3✔
312	precededMultiple(
313	[tokens.DECLARE, whitespacePlus, tokens.ORDERING, whitespacePlus],
314	or([tokens.ORDERED, tokens.UNORDERED])
315	),
316	(x) => ['orderingModeDecl', x]	×
317	);
318
319	export const emptyOrderDecl: Parser<IAST> = map(	3✔
320	precededMultiple(
321	[
322	tokens.DECLARE,
323	whitespacePlus,
324	tokens.DEFAULT,
325	whitespacePlus,
326	tokens.ORDER,
327	whitespacePlus,
328	tokens.EMPTY,
329	whitespacePlus,
330	],
331	or([tokens.GREATEST, tokens.LEAST])
332	),
333	(x) => ['emptyOrderDecl', x]	×
334	);
335
336	export const copyNamespacesDecl: Parser<IAST> = then(	3✔
337	precededMultiple(
338	[tokens.DECLARE, whitespacePlus, tokens.COPY_NAMESPACES, whitespacePlus],
339	preserveMode
340	),
341	precededMultiple([whitespace, tokens.COMMA, whitespace], inheritMode),
342	(preserveModePart, inheritModePart) => [	×
343	'copyNamespacesDecl',
344	['preserveMode', preserveModePart],
345	['inheritMode', inheritModePart],
346	]
347	);

FontoXML / fontoxpath / 4163427832

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous