fasthtmlparser-pure 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,1594 @@
1
+ """XPath 1.0 over the flat tag list: the root, elements, comments, text nodes (runs of source text between tags) and
2
+ attributes (positions in the opening tag).
3
+
4
+ All axes (except namespace), predicates, |, the operators and the XPath 1.0 functions are supported, plus
5
+ ends-with(), lower-case() and upper-case(). HTML rules apply: names are case-insensitive, the string-value of an
6
+ element is its visible text, attribute values and text are decoded. Variables are not supported.
7
+ """
8
+
9
+ import math
10
+
11
+ from . import _attrs as at
12
+ from . import _decode as dec
13
+ from . import _text
14
+ from ._chars import SPACE, SPACE_RUNS, equal_fold, is_alpha, is_digit, lower, quote, trim_space, upper, \
15
+ utf16_length
16
+ from ._css import element_at
17
+ from ._parser import COMMENT, NAMES, is_raw_text
18
+ from ._query import Query
19
+
20
+
21
+ class XPathError(ValueError):
22
+ """An invalid XPath expression, or one that cannot be evaluated."""
23
+
24
+
25
+ # value types
26
+ TYPE_NODE_SET = 0
27
+ TYPE_NUMBER = 1
28
+ TYPE_STRING = 2
29
+ TYPE_BOOLEAN = 3
30
+ TYPE_NAMES = ("node-set", "number", "string", "boolean")
31
+
32
+ # expressions
33
+ E_LITERAL = 0 # value
34
+ E_NUMBER = 1 # value
35
+ E_AND = 2 # l, r
36
+ E_OR = 3 # l, r
37
+ E_COMPARE = 4 # cmp, l, r
38
+ E_ARITH = 5 # arith, l, r
39
+ E_NEGATE = 6 # e
40
+ E_UNION = 7 # l, r
41
+ E_ATTR_EQUALS = 8 # name, value, negate: @name = 'literal' compared in place
42
+ E_ATTR_EXISTS = 9 # name: [@name]
43
+ E_PATH = 10 # start (expr or None), absolute, steps; attr: a bare @name
44
+ E_FILTER = 11 # primary, preds
45
+ E_FUNCTION = 12 # fn, args
46
+
47
+ OP_EQ = 0
48
+ OP_NEQ = 1
49
+ OP_LT = 2
50
+ OP_LE = 3
51
+ OP_GT = 4
52
+ OP_GE = 5
53
+
54
+ ARITH_ADD = 0
55
+ ARITH_SUB = 1
56
+ ARITH_MUL = 2
57
+ ARITH_DIV = 3
58
+ ARITH_MOD = 4
59
+
60
+ # node tests
61
+ TK_NAME = 0
62
+ TK_PREFIX = 1 # dc:*
63
+ TK_WILDCARD = 2 # *
64
+ TK_NODE = 3 # node()
65
+ TK_TEXT = 4 # text()
66
+ TK_COMMENT = 5 # comment()
67
+ TK_PI = 6 # processing-instruction(): never matches
68
+ TK_CONTAINER = 7 # internal: the root and elements (// before a child or attribute step)
69
+
70
+ AXIS_CHILD = 0
71
+ AXIS_DESCENDANT = 1
72
+ AXIS_DESCENDANT_OR_SELF = 2
73
+ AXIS_SELF = 3
74
+ AXIS_PARENT = 4
75
+ AXIS_ANCESTOR = 5
76
+ AXIS_ANCESTOR_OR_SELF = 6
77
+ AXIS_FOLLOWING_SIBLING = 7
78
+ AXIS_PRECEDING_SIBLING = 8
79
+ AXIS_FOLLOWING = 9
80
+ AXIS_PRECEDING = 10
81
+ AXIS_ATTRIBUTE = 11
82
+
83
+ NAN = float("nan")
84
+ INF = float("inf")
85
+
86
+
87
+ class Expr:
88
+ __slots__ = ("op", "type", "pos", "value", "l", "r", "cmp", "arith", "e", "name", "negate", "start", "absolute",
89
+ "steps", "primary", "preds", "fn", "args", "attr")
90
+
91
+ def __init__(self, op, type_, pos, **fields):
92
+ self.op = op
93
+ self.type = type_
94
+ self.pos = pos # depends on the context position or size
95
+ self.value = self.l = self.r = self.cmp = self.arith = self.e = self.name = self.negate = None
96
+ self.start = self.absolute = self.steps = self.primary = self.preds = self.fn = self.args = self.attr = None
97
+ for k, v in fields.items():
98
+ setattr(self, k, v)
99
+
100
+
101
+ class Step:
102
+ __slots__ = ("axis", "test", "preds", "positional")
103
+
104
+ def __init__(self, axis, test, preds):
105
+ self.axis = axis
106
+ self.test = test
107
+ self.preds = preds
108
+ self.positional = any(p.type == TYPE_NUMBER or p.pos for p in preds)
109
+
110
+
111
+ class NodeTest:
112
+ __slots__ = ("k", "name", "q")
113
+
114
+ def __init__(self, k, name=""):
115
+ self.k = k
116
+ self.name = name
117
+ self.q = Query(name) if k == TK_NAME else None
118
+
119
+
120
+ ANY_NODE_TEST = NodeTest(TK_NODE)
121
+ CONTAINERS_TEST = NodeTest(TK_CONTAINER)
122
+
123
+
124
+ # ----- the compiler -----
125
+
126
+ T_END = 0
127
+ T_SLASH = 1
128
+ T_DOUBLE_SLASH = 2
129
+ T_LPAREN = 3
130
+ T_RPAREN = 4
131
+ T_LBRACKET = 5
132
+ T_RBRACKET = 6
133
+ T_DOT = 7
134
+ T_DOT_DOT = 8
135
+ T_AT = 9
136
+ T_COMMA = 10
137
+ T_COLON_COLON = 11
138
+ T_PIPE = 12
139
+ T_PLUS = 13
140
+ T_MINUS = 14
141
+ T_EQ = 15
142
+ T_NEQ = 16
143
+ T_LT = 17
144
+ T_LE = 18
145
+ T_GT = 19
146
+ T_GE = 20
147
+ T_STAR = 21 # name test *
148
+ T_MULTIPLY = 22 # operator *
149
+ T_AND = 23
150
+ T_OR = 24
151
+ T_DIV = 25
152
+ T_MOD = 26
153
+ T_NAME = 27
154
+ T_LITERAL = 28
155
+ T_NUMBER = 29
156
+ T_DOLLAR = 30
157
+
158
+ SINGLE = {"(": T_LPAREN, ")": T_RPAREN, "[": T_LBRACKET, "]": T_RBRACKET, "@": T_AT, ",": T_COMMA, "|": T_PIPE,
159
+ "+": T_PLUS, "-": T_MINUS, "=": T_EQ, "$": T_DOLLAR}
160
+ NODE_TYPES = frozenset(("node", "text", "comment", "processing-instruction"))
161
+ OPERATORS = {"and": T_AND, "or": T_OR, "div": T_DIV, "mod": T_MOD}
162
+ OPERAND_ENDS = frozenset((T_RPAREN, T_RBRACKET, T_DOT, T_DOT_DOT, T_STAR, T_NAME, T_LITERAL, T_NUMBER))
163
+ AXES = {
164
+ "child": AXIS_CHILD, "descendant": AXIS_DESCENDANT, "descendant-or-self": AXIS_DESCENDANT_OR_SELF,
165
+ "self": AXIS_SELF, "parent": AXIS_PARENT, "ancestor": AXIS_ANCESTOR, "ancestor-or-self": AXIS_ANCESTOR_OR_SELF,
166
+ "following-sibling": AXIS_FOLLOWING_SIBLING, "preceding-sibling": AXIS_PRECEDING_SIBLING,
167
+ "following": AXIS_FOLLOWING, "preceding": AXIS_PRECEDING, "attribute": AXIS_ATTRIBUTE,
168
+ }
169
+ MANY = 1 << 30
170
+ # name: (min args, max args, type)
171
+ FUNCTIONS = {
172
+ "last": (0, 0, TYPE_NUMBER), "position": (0, 0, TYPE_NUMBER), "count": (1, 1, TYPE_NUMBER),
173
+ "name": (0, 1, TYPE_STRING), "local-name": (0, 1, TYPE_STRING), "string": (0, 1, TYPE_STRING),
174
+ "concat": (2, MANY, TYPE_STRING), "starts-with": (2, 2, TYPE_BOOLEAN), "ends-with": (2, 2, TYPE_BOOLEAN),
175
+ "contains": (2, 2, TYPE_BOOLEAN), "substring-before": (2, 2, TYPE_STRING),
176
+ "substring-after": (2, 2, TYPE_STRING), "substring": (2, 3, TYPE_STRING), "string-length": (0, 1, TYPE_NUMBER),
177
+ "normalize-space": (0, 1, TYPE_STRING), "translate": (3, 3, TYPE_STRING), "lower-case": (1, 1, TYPE_STRING),
178
+ "upper-case": (1, 1, TYPE_STRING), "not": (1, 1, TYPE_BOOLEAN), "true": (0, 0, TYPE_BOOLEAN),
179
+ "false": (0, 0, TYPE_BOOLEAN), "boolean": (1, 1, TYPE_BOOLEAN), "number": (0, 1, TYPE_NUMBER),
180
+ "sum": (1, 1, TYPE_NUMBER), "floor": (1, 1, TYPE_NUMBER), "ceiling": (1, 1, TYPE_NUMBER),
181
+ "round": (1, 1, TYPE_NUMBER),
182
+ }
183
+
184
+
185
+ class Token:
186
+ __slots__ = ("k", "t", "n", "p")
187
+
188
+ def __init__(self, k, t, n, p):
189
+ self.k = k
190
+ self.t = t
191
+ self.n = n
192
+ self.p = p
193
+
194
+
195
+ def _letter(ch):
196
+ return is_alpha(ch) if ch < "\x80" else ch.isalpha()
197
+
198
+
199
+ def _xname_start(ch):
200
+ return ch == "_" or _letter(ch)
201
+
202
+
203
+ def _xname_char(ch):
204
+ if ch < "\x80":
205
+ return is_alpha(ch) or is_digit(ch) or ch in "_-."
206
+ return ch.isalpha() or ch.isdecimal()
207
+
208
+
209
+ def _digit(ch):
210
+ return ch != "" and "0" <= ch <= "9"
211
+
212
+
213
+ class _Compiler:
214
+ def __init__(self, expression):
215
+ self.expression = expression
216
+ self.source = expression
217
+ self.tokens = []
218
+ self.index = 0
219
+ self.tokenize()
220
+
221
+ def parse(self):
222
+ e = self.parse_expr()
223
+ if self.peek(0).k != T_END:
224
+ self.fail(f"unexpected {self.describe(self.peek(0))}")
225
+ return e
226
+
227
+ def fail_at(self, msg, position):
228
+ raise XPathError(f"invalid XPath {quote(self.expression)} at position {position}: {msg}")
229
+
230
+ def fail(self, msg):
231
+ self.fail_at(msg, self.peek(0).p)
232
+
233
+ def tokenize(self):
234
+ s = self.source
235
+ n = len(s)
236
+ i = 0
237
+ tokens = self.tokens
238
+ while True:
239
+ while i < n and s[i] in SPACE:
240
+ i += 1
241
+ if i >= n:
242
+ tokens.append(Token(T_END, "", 0.0, i))
243
+ return
244
+ start = i
245
+ ch = s[i]
246
+ nxt = s[i + 1] if i + 1 < n else ""
247
+ # XPath 1.0 lexical rule: after a token that can end an operand, '*' and and/or/div/mod are operators
248
+ operator_expected = bool(tokens) and tokens[-1].k in OPERAND_ENDS
249
+ kind = T_END
250
+ txt = ""
251
+ number = 0.0
252
+ if ch == "/":
253
+ if nxt == "/":
254
+ kind = T_DOUBLE_SLASH
255
+ i += 2
256
+ else:
257
+ kind = T_SLASH
258
+ i += 1
259
+ elif ch in SINGLE:
260
+ kind = SINGLE[ch]
261
+ i += 1
262
+ elif ch == "*":
263
+ kind = T_MULTIPLY if operator_expected else T_STAR
264
+ i += 1
265
+ elif ch == "!":
266
+ if nxt != "=":
267
+ self.fail_at("'!' must be followed by '='", i)
268
+ kind = T_NEQ
269
+ i += 2
270
+ elif ch == "<" or ch == ">":
271
+ if nxt == "=":
272
+ kind = T_LE if ch == "<" else T_GE
273
+ i += 2
274
+ else:
275
+ kind = T_LT if ch == "<" else T_GT
276
+ i += 1
277
+ elif ch == ":":
278
+ if nxt != ":":
279
+ self.fail_at("unexpected ':'", i)
280
+ kind = T_COLON_COLON
281
+ i += 2
282
+ elif ch == '"' or ch == "'":
283
+ stop = s.find(ch, i + 1)
284
+ if stop < 0:
285
+ self.fail_at("unterminated string literal", i)
286
+ kind = T_LITERAL
287
+ txt = s[i + 1:stop]
288
+ i = stop + 1
289
+ elif ch == "." and nxt == ".":
290
+ kind = T_DOT_DOT
291
+ i += 2
292
+ elif ch == "." and not _digit(nxt):
293
+ kind = T_DOT
294
+ i += 1
295
+ elif _digit(ch) or ch == ".":
296
+ while i < n and _digit(s[i]):
297
+ i += 1
298
+ if i < n and s[i] == ".":
299
+ i += 1
300
+ while i < n and _digit(s[i]):
301
+ i += 1
302
+ kind = T_NUMBER
303
+ number = float(s[start:i])
304
+ elif _xname_start(ch):
305
+ i += 1
306
+ while i < n:
307
+ if _xname_char(s[i]):
308
+ i += 1
309
+ elif s[i] == ":" and i + 1 < n and s[i + 1] != ":" and (_xname_start(s[i + 1]) or s[i + 1] == "*"):
310
+ # a prefixed name (dc:creator) or prefix:*
311
+ i += 2
312
+ if s[i - 1] == "*":
313
+ break
314
+ else:
315
+ break
316
+ kind = T_NAME
317
+ txt = s[start:i]
318
+ if operator_expected:
319
+ op = OPERATORS.get(txt)
320
+ if op is None:
321
+ self.fail_at(f"expected an operator, found '{txt}'", start)
322
+ kind = op
323
+ else:
324
+ self.fail_at(f"unexpected character '{ch}'", i)
325
+ tokens.append(Token(kind, txt, number, start))
326
+
327
+ # ----- parser helpers -----
328
+
329
+ def peek(self, offset):
330
+ i = self.index + offset
331
+ return self.tokens[i if i < len(self.tokens) else len(self.tokens) - 1]
332
+
333
+ def advance(self):
334
+ t = self.tokens[self.index]
335
+ self.index += 1
336
+ return t
337
+
338
+ def accept(self, kind):
339
+ if self.peek(0).k != kind:
340
+ return False
341
+ self.index += 1
342
+ return True
343
+
344
+ def expect(self, kind, what):
345
+ if not self.accept(kind):
346
+ self.fail(f"expected {what}, found {self.describe(self.peek(0))}")
347
+
348
+ def describe(self, t):
349
+ if t.k == T_END:
350
+ return "the end of the expression"
351
+ if t.k == T_NAME or t.k == T_LITERAL:
352
+ return f"'{t.t}'"
353
+ if t.k == T_NUMBER:
354
+ return number_to_string(t.n)
355
+ to = min(len(self.source), t.p + 2)
356
+ return "'" + self.source[t.p:to].rstrip() + "'"
357
+
358
+ # ----- expressions -----
359
+
360
+ @staticmethod
361
+ def attribute_name(e):
362
+ """Whether the expression is a bare @name (one attribute step, no predicates); its name (lower case), or
363
+ None."""
364
+ if e.op != E_PATH or e.start is not None or e.absolute or len(e.steps) != 1:
365
+ return None
366
+ s = e.steps[0]
367
+ if s.axis != AXIS_ATTRIBUTE or s.preds or s.test.k != TK_NAME:
368
+ return None
369
+ return s.test.name.lower() if s.test.name.isascii() else _ascii_lower(s.test.name)
370
+
371
+ def make_equality(self, op, left, right):
372
+ """@name = 'literal' is compared in place; everything else by the general rules."""
373
+ name = self.attribute_name(left)
374
+ if name is not None and right.op == E_LITERAL:
375
+ return Expr(E_ATTR_EQUALS, TYPE_BOOLEAN, False, name=name, value=right.value, negate=op == OP_NEQ)
376
+ name = self.attribute_name(right)
377
+ if name is not None and left.op == E_LITERAL:
378
+ return Expr(E_ATTR_EQUALS, TYPE_BOOLEAN, False, name=name, value=left.value, negate=op == OP_NEQ)
379
+ return Expr(E_COMPARE, TYPE_BOOLEAN, left.pos or right.pos, cmp=op, l=left, r=right)
380
+
381
+ @staticmethod
382
+ def optimize(steps):
383
+ """//x is descendant-or-self::node()/child::x. Without positional predicates on x it is the same as
384
+ descendant::x: one linear scan of the tag list instead of the children of every node."""
385
+ steps = list(steps)
386
+ i = 0
387
+ while i < len(steps) - 1:
388
+ s = steps[i]
389
+ if s.axis == AXIS_DESCENDANT_OR_SELF and s.test is ANY_NODE_TEST and not s.preds:
390
+ nxt = steps[i + 1]
391
+ if nxt.axis == AXIS_CHILD and not nxt.positional:
392
+ steps[i] = Step(AXIS_DESCENDANT, nxt.test, nxt.preds)
393
+ del steps[i + 1]
394
+ elif nxt.axis == AXIS_CHILD or nxt.axis == AXIS_ATTRIBUTE:
395
+ # only the root and elements have children or attributes: skip the text nodes
396
+ steps[i] = Step(AXIS_DESCENDANT_OR_SELF, CONTAINERS_TEST, [])
397
+ i += 1
398
+ return steps
399
+
400
+ @staticmethod
401
+ def can_start_step(t):
402
+ return t.k in (T_DOT, T_DOT_DOT, T_AT, T_STAR, T_NAME)
403
+
404
+ # ----- grammar (XPath 1.0, section 3) -----
405
+
406
+ def parse_expr(self):
407
+ return self.parse_or()
408
+
409
+ def parse_or(self):
410
+ left = self.parse_and()
411
+ while self.accept(T_OR):
412
+ right = self.parse_and()
413
+ left = Expr(E_OR, TYPE_BOOLEAN, left.pos or right.pos, l=left, r=right)
414
+ return left
415
+
416
+ def parse_and(self):
417
+ left = self.parse_equality()
418
+ while self.accept(T_AND):
419
+ right = self.parse_equality()
420
+ left = Expr(E_AND, TYPE_BOOLEAN, left.pos or right.pos, l=left, r=right)
421
+ return left
422
+
423
+ def parse_equality(self):
424
+ left = self.parse_relational()
425
+ while True:
426
+ if self.accept(T_EQ):
427
+ op = OP_EQ
428
+ elif self.accept(T_NEQ):
429
+ op = OP_NEQ
430
+ else:
431
+ return left
432
+ left = self.make_equality(op, left, self.parse_relational())
433
+
434
+ def parse_relational(self):
435
+ left = self.parse_additive()
436
+ while True:
437
+ if self.accept(T_LT):
438
+ op = OP_LT
439
+ elif self.accept(T_LE):
440
+ op = OP_LE
441
+ elif self.accept(T_GT):
442
+ op = OP_GT
443
+ elif self.accept(T_GE):
444
+ op = OP_GE
445
+ else:
446
+ return left
447
+ right = self.parse_additive()
448
+ left = Expr(E_COMPARE, TYPE_BOOLEAN, left.pos or right.pos, cmp=op, l=left, r=right)
449
+
450
+ def parse_additive(self):
451
+ left = self.parse_multiplicative()
452
+ while True:
453
+ if self.accept(T_PLUS):
454
+ op = ARITH_ADD
455
+ elif self.accept(T_MINUS):
456
+ op = ARITH_SUB
457
+ else:
458
+ return left
459
+ right = self.parse_multiplicative()
460
+ left = Expr(E_ARITH, TYPE_NUMBER, left.pos or right.pos, arith=op, l=left, r=right)
461
+
462
+ def parse_multiplicative(self):
463
+ left = self.parse_unary()
464
+ while True:
465
+ if self.accept(T_MULTIPLY):
466
+ op = ARITH_MUL
467
+ elif self.accept(T_DIV):
468
+ op = ARITH_DIV
469
+ elif self.accept(T_MOD):
470
+ op = ARITH_MOD
471
+ else:
472
+ return left
473
+ right = self.parse_unary()
474
+ left = Expr(E_ARITH, TYPE_NUMBER, left.pos or right.pos, arith=op, l=left, r=right)
475
+
476
+ def parse_unary(self):
477
+ if self.accept(T_MINUS):
478
+ operand = self.parse_unary()
479
+ return Expr(E_NEGATE, TYPE_NUMBER, operand.pos, e=operand)
480
+ return self.parse_union()
481
+
482
+ def parse_union(self):
483
+ left = self.parse_path()
484
+ while self.peek(0).k == T_PIPE:
485
+ position = self.advance().p
486
+ right = self.parse_path()
487
+ if left.type != TYPE_NODE_SET or right.type != TYPE_NODE_SET:
488
+ self.fail_at("'|' needs node-sets on both sides", position)
489
+ left = Expr(E_UNION, TYPE_NODE_SET, left.pos or right.pos, l=left, r=right)
490
+ return left
491
+
492
+ def parse_path(self):
493
+ t = self.peek(0)
494
+ is_filter = t.k in (T_LITERAL, T_NUMBER, T_LPAREN, T_DOLLAR) or \
495
+ (t.k == T_NAME and self.peek(1).k == T_LPAREN and t.t not in NODE_TYPES)
496
+ if not is_filter:
497
+ return self.parse_location_path()
498
+ position = t.p
499
+ primary = self.parse_primary()
500
+ predicates = self.parse_predicates()
501
+ if predicates:
502
+ if primary.type != TYPE_NODE_SET:
503
+ self.fail_at("a predicate needs a node-set", position)
504
+ primary = Expr(E_FILTER, TYPE_NODE_SET, primary.pos, primary=primary, preds=predicates)
505
+ k = self.peek(0).k
506
+ if k != T_SLASH and k != T_DOUBLE_SLASH:
507
+ return primary
508
+ if primary.type != TYPE_NODE_SET:
509
+ self.fail_at("'/' needs a node-set on the left", position)
510
+ steps = self.optimize(self.parse_relative_steps([], True))
511
+ return Expr(E_PATH, TYPE_NODE_SET, primary.pos, start=primary, absolute=False, steps=steps)
512
+
513
+ def parse_location_path(self):
514
+ steps = []
515
+ absolute = False
516
+ if self.accept(T_SLASH):
517
+ absolute = True
518
+ if self.can_start_step(self.peek(0)):
519
+ steps = self.parse_relative_steps(steps, False)
520
+ elif self.peek(0).k == T_DOUBLE_SLASH:
521
+ absolute = True
522
+ steps = self.parse_relative_steps(steps, True)
523
+ else:
524
+ if not self.can_start_step(self.peek(0)):
525
+ self.fail(f"unexpected {self.describe(self.peek(0))}")
526
+ steps = self.parse_relative_steps(steps, False)
527
+ path = Expr(E_PATH, TYPE_NODE_SET, False, start=None, absolute=absolute, steps=self.optimize(steps))
528
+ name = self.attribute_name(path)
529
+ if name is not None:
530
+ path.attr = name # read in place where a string is needed
531
+ return path
532
+
533
+ def parse_relative_steps(self, steps, after_slash):
534
+ """Steps separated by '/' or '//'; after_slash: the next token is a '/' or '//' to read first."""
535
+ if not after_slash:
536
+ steps.append(self.parse_step())
537
+ while True:
538
+ if self.accept(T_SLASH):
539
+ steps.append(self.parse_step())
540
+ elif self.accept(T_DOUBLE_SLASH):
541
+ steps.append(Step(AXIS_DESCENDANT_OR_SELF, ANY_NODE_TEST, []))
542
+ steps.append(self.parse_step())
543
+ else:
544
+ return steps
545
+
546
+ def parse_step(self):
547
+ if self.accept(T_DOT):
548
+ return Step(AXIS_SELF, ANY_NODE_TEST, [])
549
+ if self.accept(T_DOT_DOT):
550
+ return Step(AXIS_PARENT, ANY_NODE_TEST, [])
551
+ axis = AXIS_CHILD
552
+ if self.accept(T_AT):
553
+ axis = AXIS_ATTRIBUTE
554
+ elif self.peek(0).k == T_NAME and self.peek(1).k == T_COLON_COLON:
555
+ name = self.advance()
556
+ a = AXES.get(name.t)
557
+ if a is None:
558
+ if name.t == "namespace":
559
+ self.fail_at("the namespace axis is not supported", name.p)
560
+ self.fail_at(f"unknown axis '{name.t}'", name.p)
561
+ axis = a
562
+ self.advance()
563
+ test = self.parse_node_test()
564
+ return Step(axis, test, self.parse_predicates())
565
+
566
+ def parse_node_test(self):
567
+ if self.accept(T_STAR):
568
+ return NodeTest(TK_WILDCARD)
569
+ t = self.peek(0)
570
+ if t.k != T_NAME:
571
+ self.fail(f"expected a node test, found {self.describe(t)}")
572
+ self.advance()
573
+ name = t.t
574
+ if self.peek(0).k == T_LPAREN and name in NODE_TYPES:
575
+ self.advance()
576
+ if name == "processing-instruction":
577
+ self.accept(T_LITERAL)
578
+ self.expect(T_RPAREN, "')'")
579
+ if name == "node":
580
+ return ANY_NODE_TEST
581
+ if name == "text":
582
+ return NodeTest(TK_TEXT)
583
+ if name == "comment":
584
+ return NodeTest(TK_COMMENT)
585
+ return NodeTest(TK_PI)
586
+ if name.endswith(":*"):
587
+ return NodeTest(TK_PREFIX, name[:-1])
588
+ return NodeTest(TK_NAME, name)
589
+
590
+ def parse_predicates(self):
591
+ predicates = []
592
+ while self.accept(T_LBRACKET):
593
+ p = self.parse_expr()
594
+ self.expect(T_RBRACKET, "']'")
595
+ # [@name]: an existence check instead of a node-set
596
+ name = self.attribute_name(p)
597
+ if name is not None:
598
+ p = Expr(E_ATTR_EXISTS, TYPE_BOOLEAN, False, name=name)
599
+ predicates.append(p)
600
+ return predicates
601
+
602
+ def parse_primary(self):
603
+ t = self.advance()
604
+ if t.k == T_LITERAL:
605
+ return Expr(E_LITERAL, TYPE_STRING, False, value=t.t)
606
+ if t.k == T_NUMBER:
607
+ return Expr(E_NUMBER, TYPE_NUMBER, False, value=t.n)
608
+ if t.k == T_LPAREN:
609
+ e = self.parse_expr()
610
+ self.expect(T_RPAREN, "')'")
611
+ return e
612
+ if t.k == T_DOLLAR:
613
+ self.fail_at("variables are not supported", t.p)
614
+
615
+ # function call
616
+ info = FUNCTIONS.get(t.t)
617
+ if info is None:
618
+ self.fail_at(f"unknown function '{t.t}()'", t.p)
619
+ self.expect(T_LPAREN, "'('")
620
+ args = []
621
+ if not self.accept(T_RPAREN):
622
+ while True:
623
+ args.append(self.parse_expr())
624
+ if not self.accept(T_COMMA):
625
+ break
626
+ self.expect(T_RPAREN, "')'")
627
+ fn = t.t
628
+ if len(args) < info[0] or len(args) > info[1]:
629
+ self.fail_at(f"wrong number of arguments for {fn}()", t.p)
630
+ if fn in ("count", "sum", "name", "local-name") and args and args[0].type != TYPE_NODE_SET:
631
+ self.fail_at(f"{fn}() needs a node-set argument", t.p)
632
+ pos = fn == "position" or fn == "last" or any(a.pos for a in args)
633
+ return Expr(E_FUNCTION, info[2], pos, fn=fn, args=args)
634
+
635
+
636
+ def _ascii_lower(s):
637
+ from ._chars import ascii_lower
638
+ return ascii_lower(s)
639
+
640
+
641
+ def compile_xpath(expression):
642
+ return _Compiler(expression).parse()
643
+
644
+
645
+ def number_to_string(d):
646
+ """The shortest round-trip digits, written without an exponent (XPath has none), as JavaScript writes a
647
+ number."""
648
+ if d != d:
649
+ return "NaN"
650
+ if d in (INF, -INF):
651
+ return "Infinity" if d > 0 else "-Infinity"
652
+ if d == 0:
653
+ return "0"
654
+ if d == math.floor(d) and abs(d) < 1e15:
655
+ return str(int(d))
656
+ r = repr(abs(d))
657
+ if "e" in r:
658
+ mantissa, exponent = r.split("e")
659
+ exponent = int(exponent)
660
+ else:
661
+ mantissa, exponent = r, 0
662
+ if "." in mantissa:
663
+ int_part, frac = mantissa.split(".")
664
+ else:
665
+ int_part, frac = mantissa, ""
666
+ digits = int_part + frac
667
+ point_at = len(int_part) + exponent
668
+ while len(digits) > 1 and digits.startswith("0"):
669
+ digits = digits[1:]
670
+ point_at -= 1
671
+ digits = digits.rstrip("0")
672
+ n = len(digits)
673
+ out = "-" if d < 0 else ""
674
+ if point_at <= 0:
675
+ return out + "0." + "0" * -point_at + digits
676
+ if point_at >= n:
677
+ return out + digits + "0" * (point_at - n)
678
+ return out + digits[:point_at] + "." + digits[point_at:]
679
+
680
+
681
+ # ----- the data model -----
682
+
683
+ ROOT = 0
684
+ ELEMENT = 1
685
+ COMMENT_NODE = 2
686
+ TEXT = 3
687
+ ATTRIBUTE = 4
688
+
689
+
690
+ class XNode:
691
+ """tag: element / comment: the tag; text / attribute: the parent element (-1: the root).
692
+ start: text: first char; attribute: name start. length: text: length; attribute: name length.
693
+ value_start: attribute: value start (-1 for no value).
694
+ major, minor: document order and identity: tags and text nodes by their first char; attributes right after
695
+ their element."""
696
+
697
+ __slots__ = ("kind", "tag", "start", "length", "value_start", "value_length", "major", "minor")
698
+
699
+ def __init__(self, kind, tag, major, start=0, length=0, value_start=0, value_length=0):
700
+ self.kind = kind
701
+ self.tag = tag
702
+ self.start = start
703
+ self.length = length
704
+ self.value_start = value_start
705
+ self.value_length = value_length
706
+ self.major = major
707
+ self.minor = start if kind == ATTRIBUTE else 0
708
+
709
+
710
+ _ROOT = XNode(ROOT, -1, -1)
711
+
712
+
713
+ def of_tag(d, i):
714
+ return XNode(COMMENT_NODE if d.keys[i] == COMMENT else ELEMENT, i, d.starts[i])
715
+
716
+
717
+ def _range_start(x):
718
+ """The first source position the node covers (for following / preceding)."""
719
+ return -1 if x.kind == ROOT else x.major
720
+
721
+
722
+ def _range_end(d, x):
723
+ """The last source position the node covers."""
724
+ k = x.kind
725
+ if k == ROOT:
726
+ return INF
727
+ if k == ELEMENT or k == COMMENT_NODE:
728
+ return d.ends[x.tag]
729
+ if k == TEXT:
730
+ return x.start + x.length - 1
731
+ return d.starts[x.tag] # attribute: the children of its element follow it
732
+
733
+
734
+ # ----- evaluation -----
735
+
736
+ def _matches_text(test):
737
+ return test.k == TK_NODE or test.k == TK_TEXT
738
+
739
+
740
+ def _matches_tags(test):
741
+ return test.k != TK_TEXT and test.k != TK_PI
742
+
743
+
744
+ def _matches_attribute(test, attribute):
745
+ k = test.k
746
+ if k == TK_NAME:
747
+ return equal_fold(attribute, test.name)
748
+ if k == TK_PREFIX:
749
+ n = len(test.name)
750
+ return len(attribute) >= n and equal_fold(attribute[:n], test.name)
751
+ return k == TK_WILDCARD or k == TK_NODE
752
+
753
+
754
+ def _reverse(axis):
755
+ return axis in (AXIS_ANCESTOR, AXIS_ANCESTOR_OR_SELF, AXIS_PRECEDING, AXIS_PRECEDING_SIBLING)
756
+
757
+
758
+ def _fmod(x, y):
759
+ """C fmod: the remainder has the sign of x."""
760
+ if x != x or y != y or x in (INF, -INF) or y == 0:
761
+ return NAN
762
+ if y in (INF, -INF):
763
+ return x
764
+ return math.fmod(x, y)
765
+
766
+
767
+ def _float_floor(v):
768
+ if v != v or v in (INF, -INF):
769
+ return v
770
+ r = float(math.floor(v))
771
+ return -0.0 if r == 0 and v < 0 else r
772
+
773
+
774
+ def _float_ceil(v):
775
+ if v != v or v in (INF, -INF):
776
+ return v
777
+ r = float(math.ceil(v))
778
+ return -0.0 if r == 0 and v < 0 else r
779
+
780
+
781
+ def _round(v):
782
+ if v != v or v in (INF, -INF):
783
+ return v
784
+ return _float_floor(v + 0.5)
785
+
786
+
787
+ def _to_boolean(v):
788
+ if v is True or v is False:
789
+ return v
790
+ if isinstance(v, float):
791
+ return v != 0 and v == v
792
+ return len(v) > 0
793
+
794
+
795
+ def _string_to_number(value):
796
+ """Optional '-', digits with an optional decimal point; anything else is NaN."""
797
+ s = trim_space(value)
798
+ body = s[1:] if s.startswith("-") else s
799
+ if not body or not all(c in "0123456789." for c in body):
800
+ return NAN
801
+ dots = body.count(".")
802
+ if dots > 1 or len(body) == dots:
803
+ return NAN
804
+ return float(s)
805
+
806
+
807
+ class Evaluator:
808
+ """The evaluation of one expression on one document: values are a node-set (a list of XNode), a float, a str
809
+ or True / False."""
810
+
811
+ __slots__ = ("d", "all")
812
+
813
+ def __init__(self, d):
814
+ self.d = d
815
+ self.all = None
816
+
817
+ # ----- node tests -----
818
+
819
+ def matches_tag_at(self, test, i):
820
+ """The node test on the tag at index i."""
821
+ d = self.d
822
+ k = test.k
823
+ if k == TK_NAME:
824
+ return test.q.name_matches_at(d, i)
825
+ if k == TK_PREFIX:
826
+ key = d.keys[i]
827
+ name = NAMES[key] if key >= 0 else d.customs[i]
828
+ n = len(test.name)
829
+ return element_at(d, i) and len(name) >= n and equal_fold(name[:n], test.name)
830
+ if k == TK_WILDCARD or k == TK_CONTAINER:
831
+ return element_at(d, i)
832
+ if k == TK_NODE:
833
+ return element_at(d, i) or d.keys[i] == COMMENT
834
+ if k == TK_COMMENT:
835
+ return d.keys[i] == COMMENT
836
+ return False
837
+
838
+ def matches(self, test, x, attribute_axis):
839
+ k = x.kind
840
+ if k == ROOT:
841
+ return test.k == TK_NODE or test.k == TK_CONTAINER
842
+ if k == ELEMENT or k == COMMENT_NODE:
843
+ return self.matches_tag_at(test, x.tag)
844
+ if k == TEXT:
845
+ return _matches_text(test)
846
+ if attribute_axis:
847
+ return _matches_attribute(test, self.d.src[x.start:x.start + x.length])
848
+ return test.k == TK_NODE
849
+
850
+ # ----- navigation -----
851
+
852
+ def add_children(self, x, test, out):
853
+ """Appends the children of the root or an element that match the test, text nodes included, in document
854
+ order."""
855
+ want_text = _matches_text(test)
856
+ want_tags = _matches_tags(test)
857
+ if not want_text and not want_tags:
858
+ return
859
+ d = self.d
860
+ if x.kind == ROOT:
861
+ first = 0
862
+ end = INF
863
+ child_depth = 0
864
+ p = 0
865
+ text_end = len(d.src)
866
+ parent = -1
867
+ elif x.kind == ELEMENT and d.inner_starts[x.tag] > 0 and d.inner_ends[x.tag] > 0:
868
+ t = x.tag
869
+ first = t + 1
870
+ end = d.ends[t]
871
+ child_depth = d.depths[t] + 1
872
+ p = d.inner_starts[t]
873
+ text_end = d.inner_ends[t] + 1
874
+ parent = t
875
+ else:
876
+ return
877
+ ends = d.ends
878
+ depths = d.depths
879
+ starts = d.starts
880
+ keys = d.keys
881
+ count = len(ends)
882
+ i = first
883
+ while i < count:
884
+ if ends[i] > end:
885
+ break
886
+ if depths[i] == child_depth:
887
+ start = starts[i]
888
+ if want_text and start > p:
889
+ e = start if start < text_end else text_end
890
+ if e > p:
891
+ out.append(XNode(TEXT, parent, p, p, e - p))
892
+ if want_tags and self.matches_tag_at(test, i):
893
+ out.append(XNode(COMMENT_NODE if keys[i] == COMMENT else ELEMENT, i, start))
894
+ p = ends[i] + 1
895
+ i += 1
896
+ if want_text and text_end > p:
897
+ out.append(XNode(TEXT, parent, p, p, text_end - p))
898
+
899
+ def add_descendants(self, x, test, out):
900
+ """Appends the descendants of the root or an element that match the test, in document order."""
901
+ if _matches_text(test):
902
+ self.add_descendants_with_text(x, test, out)
903
+ return
904
+ if not _matches_tags(test):
905
+ return
906
+ d = self.d
907
+ if x.kind == ROOT:
908
+ first = 0
909
+ end = INF
910
+ elif x.kind == ELEMENT and d.inner_starts[x.tag] > 0 and d.inner_ends[x.tag] > 0:
911
+ first = x.tag + 1
912
+ end = d.ends[x.tag]
913
+ else:
914
+ return
915
+ # tags only: one linear scan of the flat list
916
+ ends = d.ends
917
+ starts = d.starts
918
+ keys = d.keys
919
+ count = len(ends)
920
+ i = first
921
+ if test.k == TK_NAME:
922
+ q = test.q
923
+ qk = q.key
924
+ named = q.tag_name != ""
925
+ customs = d.customs
926
+ while i < count:
927
+ if ends[i] > end:
928
+ break
929
+ # a known name: one int compare on the arrays
930
+ k = keys[i]
931
+ if (k == qk or (k < 0 and named and equal_fold(customs[i], q.tag_name))) if qk >= 0 \
932
+ else q.name_matches_at(d, i):
933
+ out.append(XNode(ELEMENT, i, starts[i]))
934
+ i += 1
935
+ return
936
+ while i < count:
937
+ if ends[i] > end:
938
+ break
939
+ if self.matches_tag_at(test, i):
940
+ out.append(XNode(COMMENT_NODE if keys[i] == COMMENT else ELEMENT, i, starts[i]))
941
+ i += 1
942
+
943
+ def add_descendants_with_text(self, x, test, out):
944
+ children = []
945
+ self.add_children(x, ANY_NODE_TEST, children)
946
+ for child in children:
947
+ if self.matches(test, child, False):
948
+ out.append(child)
949
+ if child.kind == ELEMENT:
950
+ self.add_descendants_with_text(child, test, out)
951
+
952
+ def parent_node(self, x):
953
+ k = x.kind
954
+ if k == ROOT:
955
+ return None
956
+ d = self.d
957
+ if k == TEXT or k == ATTRIBUTE:
958
+ return _ROOT if x.tag < 0 else of_tag(d, x.tag)
959
+ t = x.tag
960
+ p = d.parents[t]
961
+ return of_tag(d, p) if d.depths[t] > 0 and p >= 0 else _ROOT
962
+
963
+ def add_attributes(self, x, test, out):
964
+ if x.kind != ELEMENT:
965
+ return
966
+ s = at.AttrScanner(self.d, x.tag)
967
+ major = self.d.starts[x.tag]
968
+ while s.next():
969
+ if _matches_attribute(test, s.name()):
970
+ out.append(XNode(ATTRIBUTE, x.tag, major, s.name_start, s.name_length, s.value_start,
971
+ s.value_length))
972
+
973
+ def attribute_of(self, x, name):
974
+ """The raw value of the first attribute with the name (lower case); None when the element has none."""
975
+ if x.kind != ELEMENT:
976
+ return None
977
+ raw = at.attr_raw(self.d, x.tag, name)
978
+ if raw:
979
+ return raw
980
+ return raw if at.has_attribute(self.d, x.tag, name) else None
981
+
982
+ def string_value(self, x):
983
+ """The root and elements give their visible text; text nodes and attributes their decoded value; comments
984
+ their content."""
985
+ d = self.d
986
+ k = x.kind
987
+ if k == ROOT:
988
+ return _text.clear_tags(d.src)
989
+ if k == ELEMENT:
990
+ return d.text_of(x.tag)
991
+ if k == ATTRIBUTE:
992
+ if x.value_start < 0:
993
+ return ""
994
+ return dec.decode(d.src[x.value_start:x.value_start + x.value_length], True)
995
+ if k == TEXT:
996
+ text = d.src[x.start:x.start + x.length]
997
+ if x.tag >= 0 and is_raw_text(d.keys[x.tag]):
998
+ return dec.normalize_newlines(text)
999
+ return dec.decode(text, False)
1000
+ # comment
1001
+ t = x.tag
1002
+ source = d.src[d.starts[t]:d.ends[t] + 1]
1003
+ if source.startswith("<!--"):
1004
+ source = source[4:]
1005
+ if source.endswith("-->"):
1006
+ source = source[:-3]
1007
+ return source
1008
+
1009
+ def node_name(self, x):
1010
+ """name() / local-name(): the lower-case tag or attribute name; "" for other nodes."""
1011
+ if x.kind == ELEMENT:
1012
+ return self.d.name_of(x.tag)
1013
+ if x.kind == ATTRIBUTE:
1014
+ return lower(self.d.src[x.start:x.start + x.length])
1015
+ return ""
1016
+
1017
+ # ----- values -----
1018
+
1019
+ def to_number(self, v):
1020
+ if isinstance(v, float):
1021
+ return v
1022
+ if v is True:
1023
+ return 1.0
1024
+ if v is False:
1025
+ return 0.0
1026
+ if isinstance(v, str):
1027
+ return _string_to_number(v)
1028
+ return NAN if not v else _string_to_number(self.string_value(v[0]))
1029
+
1030
+ def to_str(self, v):
1031
+ if isinstance(v, str):
1032
+ return v
1033
+ if v is True:
1034
+ return "true"
1035
+ if v is False:
1036
+ return "false"
1037
+ if isinstance(v, float):
1038
+ return number_to_string(v)
1039
+ return "" if not v else self.string_value(v[0])
1040
+
1041
+ @staticmethod
1042
+ def sort_unique(nodes):
1043
+ """Puts the nodes in document order without duplicates."""
1044
+ count = len(nodes)
1045
+ if count < 2:
1046
+ return nodes
1047
+ for i in range(1, count):
1048
+ a = nodes[i - 1]
1049
+ b = nodes[i]
1050
+ if a.major > b.major or (a.major == b.major and a.minor >= b.minor):
1051
+ break
1052
+ else:
1053
+ return nodes
1054
+ # stable: ties keep their order
1055
+ nodes = sorted(nodes, key=lambda n: (n.major, n.minor))
1056
+ out = [nodes[0]]
1057
+ last = nodes[0]
1058
+ for n in nodes[1:]:
1059
+ if n.major != last.major or n.minor != last.minor:
1060
+ out.append(n)
1061
+ last = n
1062
+ return out
1063
+
1064
+ def all_nodes(self):
1065
+ if self.all is None:
1066
+ a = []
1067
+ self.add_descendants(_ROOT, ANY_NODE_TEST, a)
1068
+ self.all = a
1069
+ return self.all
1070
+
1071
+ def eval_nodes(self, e, node, position, size):
1072
+ v = self.eval_expr(e, node, position, size)
1073
+ if isinstance(v, list):
1074
+ return v
1075
+ raise XPathError("the XPath expression does not give a node-set")
1076
+
1077
+ def eval_string(self, e, node, position, size):
1078
+ if e.attr is not None:
1079
+ # a bare @name: the string-value of the first such attribute, read in place
1080
+ raw = at.attr_raw(self.d, node.tag, e.attr) if node.kind == ELEMENT else ""
1081
+ return dec.decode(raw, True) if "&" in raw or "\r" in raw else raw
1082
+ return self.to_str(self.eval_expr(e, node, position, size))
1083
+
1084
+ def eval_number(self, e, node, position, size):
1085
+ return self.to_number(self.eval_expr(e, node, position, size))
1086
+
1087
+ def eval_bool(self, e, node, position, size):
1088
+ op = e.op
1089
+ if op == E_LITERAL:
1090
+ return e.value != ""
1091
+ if op == E_AND:
1092
+ return self.eval_bool(e.l, node, position, size) and self.eval_bool(e.r, node, position, size)
1093
+ if op == E_OR:
1094
+ return self.eval_bool(e.l, node, position, size) or self.eval_bool(e.r, node, position, size)
1095
+ if op == E_COMPARE:
1096
+ return self.compare(e.cmp, self.eval_expr(e.l, node, position, size),
1097
+ self.eval_expr(e.r, node, position, size))
1098
+ if op == E_ATTR_EQUALS:
1099
+ # '!=' is true when the attribute exists and differs (a missing attribute is an empty node-set)
1100
+ raw = self.attribute_of(node, e.name)
1101
+ return raw is not None and at.attr_equals(raw, e.value) != e.negate
1102
+ if op == E_ATTR_EXISTS:
1103
+ return self.attribute_of(node, e.name) is not None
1104
+ return _to_boolean(self.eval_expr(e, node, position, size))
1105
+
1106
+ def eval_predicate(self, e, node, position, size):
1107
+ """A number compares with the position, anything else is converted to boolean."""
1108
+ if e.type == TYPE_BOOLEAN:
1109
+ return self.eval_bool(e, node, position, size)
1110
+ v = self.eval_expr(e, node, position, size)
1111
+ if isinstance(v, float):
1112
+ return v == position
1113
+ return _to_boolean(v)
1114
+
1115
+ def eval_expr(self, e, node, position, size):
1116
+ op = e.op
1117
+ if op == E_LITERAL or op == E_NUMBER:
1118
+ return e.value
1119
+ if op in (E_AND, E_OR, E_COMPARE, E_ATTR_EQUALS, E_ATTR_EXISTS):
1120
+ return self.eval_bool(e, node, position, size)
1121
+ if op == E_ARITH:
1122
+ x = self.eval_number(e.l, node, position, size)
1123
+ y = self.eval_number(e.r, node, position, size)
1124
+ a = e.arith
1125
+ if a == ARITH_ADD:
1126
+ return x + y
1127
+ if a == ARITH_SUB:
1128
+ return x - y
1129
+ if a == ARITH_MUL:
1130
+ return x * y
1131
+ if a == ARITH_DIV:
1132
+ if y == 0:
1133
+ if x != x or x == 0:
1134
+ return NAN
1135
+ return math.copysign(INF, x) * math.copysign(1.0, y)
1136
+ return x / y
1137
+ return _fmod(x, y)
1138
+ if op == E_NEGATE:
1139
+ return -self.eval_number(e.e, node, position, size)
1140
+ if op == E_UNION:
1141
+ a = self.eval_nodes(e.l, node, position, size)
1142
+ b = self.eval_nodes(e.r, node, position, size)
1143
+ return self.sort_unique(a + b)
1144
+ if op == E_PATH:
1145
+ if e.start is not None:
1146
+ current = self.eval_nodes(e.start, node, position, size)
1147
+ elif e.absolute:
1148
+ current = [_ROOT]
1149
+ else:
1150
+ current = [node]
1151
+ for s in e.steps:
1152
+ if not current:
1153
+ break
1154
+ current = self.apply_step(s, current)
1155
+ return current
1156
+ if op == E_FILTER:
1157
+ return self.filter(self.eval_nodes(e.primary, node, position, size), e.preds)
1158
+ return self.eval_function(e, node, position, size)
1159
+
1160
+ def compare(self, op, a, b):
1161
+ if isinstance(a, list):
1162
+ if isinstance(b, list):
1163
+ if not a or not b:
1164
+ return False
1165
+ values_b = [self.string_value(n) for n in b]
1166
+ for x in a:
1167
+ value = self.string_value(x)
1168
+ for other in values_b:
1169
+ if self.compare_atoms(op, value, other):
1170
+ return True
1171
+ return False
1172
+ return self.compare_with_nodes(op, a, b, True)
1173
+ if isinstance(b, list):
1174
+ return self.compare_with_nodes(op, b, a, False)
1175
+ return self.compare_atoms(op, a, b)
1176
+
1177
+ def compare_with_nodes(self, op, nodes, other, nodes_on_left):
1178
+ if other is True or other is False:
1179
+ as_bool = len(nodes) > 0
1180
+ return self.compare_atoms(op, as_bool, other) if nodes_on_left else self.compare_atoms(op, other, as_bool)
1181
+ is_number = isinstance(other, float)
1182
+ for n in nodes:
1183
+ s = self.string_value(n)
1184
+ value = _string_to_number(s) if is_number else s
1185
+ if self.compare_atoms(op, value, other) if nodes_on_left else self.compare_atoms(op, other, value):
1186
+ return True
1187
+ return False
1188
+
1189
+ def compare_atoms(self, op, a, b):
1190
+ if op == OP_EQ or op == OP_NEQ:
1191
+ if a is True or a is False or b is True or b is False:
1192
+ eq = _to_boolean(a) == _to_boolean(b)
1193
+ elif isinstance(a, float) or isinstance(b, float):
1194
+ eq = self.to_number(a) == self.to_number(b)
1195
+ else:
1196
+ eq = self.to_str(a) == self.to_str(b)
1197
+ return eq == (op == OP_EQ)
1198
+ x = self.to_number(a)
1199
+ y = self.to_number(b)
1200
+ if op == OP_LT:
1201
+ return x < y
1202
+ if op == OP_LE:
1203
+ return x <= y
1204
+ if op == OP_GT:
1205
+ return x > y
1206
+ return x >= y
1207
+
1208
+ # ----- steps -----
1209
+
1210
+ def apply_step(self, step, inp):
1211
+ if len(inp) == 1:
1212
+ out = []
1213
+ self.select_from(step, inp[0], out)
1214
+ return out
1215
+
1216
+ # Nested input nodes (//div//a on divs inside divs, //a/ancestor::* on links in one list) give the same
1217
+ # nodes again and again: n nested nodes would collect about n^2 nodes before the duplicates are removed.
1218
+ # When the predicates do not depend on the position, a node passes them or not whichever input node it
1219
+ # comes from, so the input nodes whose results are already collected are skipped: the work stays linear.
1220
+ if not step.positional:
1221
+ if step.axis == AXIS_DESCENDANT or step.axis == AXIS_DESCENDANT_OR_SELF:
1222
+ if not _matches_text(step.test) and self.in_document_order(inp):
1223
+ return self.sort_unique(self.select_descendants_of_nested(step, inp))
1224
+ elif step.axis == AXIS_ANCESTOR or step.axis == AXIS_ANCESTOR_OR_SELF:
1225
+ return self.sort_unique(self.select_shared_ancestors(step, inp))
1226
+
1227
+ out = []
1228
+ for x in inp:
1229
+ self.select_from(step, x, out)
1230
+ return self.sort_unique(out)
1231
+
1232
+ def select_descendants_of_nested(self, step, inp):
1233
+ """The descendant axes (tags only) on input nodes in document order. A tag that lies in the part of the tag
1234
+ list already scanned for an earlier input node is skipped."""
1235
+ d = self.d
1236
+ ends = d.ends
1237
+ count = len(ends)
1238
+ out = []
1239
+ scanned_to = -1 # the tags before this index were scanned for an earlier input node
1240
+ for x in inp:
1241
+ if x.kind == ELEMENT or x.kind == COMMENT_NODE:
1242
+ t = x.tag
1243
+ if t < scanned_to:
1244
+ continue
1245
+ self.select_from(step, x, out)
1246
+ # where add_descendants stops for this tag
1247
+ if x.kind == ELEMENT and d.inner_starts[t] > 0 and d.inner_ends[t] > 0:
1248
+ k = t + 1
1249
+ end = ends[t]
1250
+ while k < count and ends[k] <= end:
1251
+ k += 1
1252
+ if k > scanned_to:
1253
+ scanned_to = k
1254
+ else:
1255
+ self.select_from(step, x, out)
1256
+ if x.kind == ROOT:
1257
+ scanned_to = INF
1258
+ return out
1259
+
1260
+ def select_shared_ancestors(self, step, inp):
1261
+ """The walk up from an input node stops at an ancestor already reached from an earlier one, because that
1262
+ walk has gone on to the root. Only the root and elements are marked: they are the only parents."""
1263
+ visited = set()
1264
+ out = []
1265
+ test = step.test
1266
+ for x in inp:
1267
+ start = len(out)
1268
+ current = x
1269
+ if step.axis == AXIS_ANCESTOR_OR_SELF:
1270
+ container = current.kind == ROOT or current.kind == ELEMENT
1271
+ if container and current.major in visited:
1272
+ continue
1273
+ if container:
1274
+ visited.add(current.major)
1275
+ if self.matches(test, current, False):
1276
+ out.append(current)
1277
+ while True:
1278
+ p = self.parent_node(current)
1279
+ if p is None or p.major in visited:
1280
+ break
1281
+ visited.add(p.major)
1282
+ current = p
1283
+ if self.matches(test, current, False):
1284
+ out.append(current)
1285
+ if step.preds and len(out) > start:
1286
+ out[start:] = self.filter(out[start:], step.preds)
1287
+ return out
1288
+
1289
+ def select_from(self, step, x, out):
1290
+ """Appends the nodes of the axis that pass the test and the predicates, in document order."""
1291
+ reverse = _reverse(step.axis)
1292
+ if not step.preds and not reverse:
1293
+ self.collect(step, x, out)
1294
+ return
1295
+ selected = []
1296
+ self.collect(step, x, selected)
1297
+ selected = self.filter(selected, step.preds)
1298
+ if reverse:
1299
+ selected.reverse()
1300
+ out.extend(selected)
1301
+
1302
+ def collect(self, step, x, out):
1303
+ """Appends the nodes of the axis that pass the node test, in axis order (reverse axes: nearest first)."""
1304
+ test = step.test
1305
+ axis = step.axis
1306
+ if axis == AXIS_CHILD:
1307
+ self.add_children(x, test, out)
1308
+ elif axis == AXIS_DESCENDANT:
1309
+ self.add_descendants(x, test, out)
1310
+ elif axis == AXIS_DESCENDANT_OR_SELF:
1311
+ if self.matches(test, x, False):
1312
+ out.append(x)
1313
+ self.add_descendants(x, test, out)
1314
+ elif axis == AXIS_SELF:
1315
+ if self.matches(test, x, False):
1316
+ out.append(x)
1317
+ elif axis == AXIS_PARENT:
1318
+ p = self.parent_node(x)
1319
+ if p is not None and self.matches(test, p, False):
1320
+ out.append(p)
1321
+ elif axis == AXIS_ANCESTOR or axis == AXIS_ANCESTOR_OR_SELF:
1322
+ current = x
1323
+ if axis == AXIS_ANCESTOR_OR_SELF and self.matches(test, current, False):
1324
+ out.append(current)
1325
+ while True:
1326
+ current = self.parent_node(current)
1327
+ if current is None:
1328
+ break
1329
+ if self.matches(test, current, False):
1330
+ out.append(current)
1331
+ elif axis == AXIS_FOLLOWING_SIBLING or axis == AXIS_PRECEDING_SIBLING:
1332
+ self.collect_siblings(x, test, out, axis == AXIS_FOLLOWING_SIBLING)
1333
+ elif axis == AXIS_FOLLOWING:
1334
+ self.collect_following(x, test, out)
1335
+ elif axis == AXIS_PRECEDING:
1336
+ self.collect_preceding(x, test, out)
1337
+ elif axis == AXIS_ATTRIBUTE:
1338
+ self.add_attributes(x, test, out)
1339
+
1340
+ @staticmethod
1341
+ def in_document_order(nodes):
1342
+ for i in range(1, len(nodes)):
1343
+ a = nodes[i - 1]
1344
+ b = nodes[i]
1345
+ if a.major > b.major or (a.major == b.major and a.minor >= b.minor):
1346
+ return False
1347
+ return True
1348
+
1349
+ def collect_siblings(self, x, test, out, following):
1350
+ if x.kind == ROOT or x.kind == ATTRIBUTE:
1351
+ return
1352
+ d = self.d
1353
+ if not _matches_text(test) and x.kind != TEXT:
1354
+ # tags only: walk the flat list; deeper tags are inside the siblings, a shallower one ends the parent
1355
+ t = x.tag
1356
+ depths = d.depths
1357
+ depth = depths[t]
1358
+ count = len(depths)
1359
+ step_by = 1 if following else -1
1360
+ i = t + step_by
1361
+ while 0 <= i < count:
1362
+ if depths[i] < depth:
1363
+ break
1364
+ if depths[i] == depth and self.matches_tag_at(test, i):
1365
+ out.append(of_tag(d, i))
1366
+ i += step_by
1367
+ return
1368
+ parent = self.parent_node(x)
1369
+ if parent is None:
1370
+ return
1371
+ siblings = []
1372
+ self.add_children(parent, ANY_NODE_TEST, siblings)
1373
+ index = -1
1374
+ for k, s in enumerate(siblings):
1375
+ if s.major == x.major and s.minor == x.minor:
1376
+ index = k
1377
+ break
1378
+ if index < 0:
1379
+ return
1380
+ if following:
1381
+ for s in siblings[index + 1:]:
1382
+ if self.matches(test, s, False):
1383
+ out.append(s)
1384
+ else:
1385
+ for k in range(index - 1, -1, -1):
1386
+ if self.matches(test, siblings[k], False):
1387
+ out.append(siblings[k])
1388
+
1389
+ def collect_following(self, x, test, out):
1390
+ if x.kind == ROOT:
1391
+ return
1392
+ d = self.d
1393
+ after = _range_end(d, x)
1394
+ if _matches_text(test):
1395
+ for n in self.all_nodes():
1396
+ if _range_start(n) > after and self.matches(test, n, False):
1397
+ out.append(n)
1398
+ return
1399
+ starts = d.starts
1400
+ i = x.tag + 1 if x.kind == ELEMENT or x.kind == COMMENT_NODE else 0
1401
+ count = len(starts)
1402
+ while i < count:
1403
+ if starts[i] > after and self.matches_tag_at(test, i):
1404
+ out.append(of_tag(d, i))
1405
+ i += 1
1406
+
1407
+ def collect_preceding(self, x, test, out):
1408
+ if x.kind == ROOT:
1409
+ return
1410
+ d = self.d
1411
+ before = _range_start(x)
1412
+ if _matches_text(test):
1413
+ a = self.all_nodes()
1414
+ for k in range(len(a) - 1, -1, -1):
1415
+ if _range_end(d, a[k]) < before and self.matches(test, a[k], False):
1416
+ out.append(a[k])
1417
+ return
1418
+ ends = d.ends
1419
+ i = x.tag - 1 if x.kind == ELEMENT or x.kind == COMMENT_NODE else len(ends) - 1
1420
+ while i >= 0:
1421
+ if ends[i] < before and self.matches_tag_at(test, i):
1422
+ out.append(of_tag(d, i))
1423
+ i -= 1
1424
+
1425
+ def filter(self, nodes, predicates):
1426
+ """Applies the predicates one after another; positions are 1-based in the order of the list."""
1427
+ for p in predicates:
1428
+ size = len(nodes)
1429
+ nodes = [n for k, n in enumerate(nodes) if self.eval_predicate(p, n, k + 1, size)]
1430
+ return nodes
1431
+
1432
+ # ----- functions -----
1433
+
1434
+ def eval_function(self, e, node, position, size):
1435
+ args = e.args
1436
+ fn = e.fn
1437
+ if fn == "last":
1438
+ return float(size)
1439
+ if fn == "position":
1440
+ return float(position)
1441
+ if fn == "count":
1442
+ return float(len(self.eval_nodes(args[0], node, position, size)))
1443
+ if fn == "name" or fn == "local-name":
1444
+ name = ""
1445
+ if not args:
1446
+ name = self.node_name(node)
1447
+ else:
1448
+ s = self.eval_nodes(args[0], node, position, size)
1449
+ if s:
1450
+ name = self.node_name(s[0])
1451
+ if fn == "local-name":
1452
+ colon = name.rfind(":")
1453
+ return name if colon < 0 else name[colon + 1:]
1454
+ return name
1455
+ if fn == "string":
1456
+ return self.string_value(node) if not args else self.eval_string(args[0], node, position, size)
1457
+ if fn == "concat":
1458
+ return "".join(self.eval_string(a, node, position, size) for a in args)
1459
+ if fn == "starts-with":
1460
+ return self.eval_string(args[0], node, position, size).startswith(
1461
+ self.eval_string(args[1], node, position, size))
1462
+ if fn == "ends-with":
1463
+ return self.eval_string(args[0], node, position, size).endswith(
1464
+ self.eval_string(args[1], node, position, size))
1465
+ if fn == "contains":
1466
+ return self.eval_string(args[1], node, position, size) in self.eval_string(args[0], node, position, size)
1467
+ if fn == "substring-before":
1468
+ s = self.eval_string(args[0], node, position, size)
1469
+ i = s.find(self.eval_string(args[1], node, position, size))
1470
+ return "" if i < 0 else s[:i]
1471
+ if fn == "substring-after":
1472
+ s = self.eval_string(args[0], node, position, size)
1473
+ t = self.eval_string(args[1], node, position, size)
1474
+ i = s.find(t)
1475
+ return "" if i < 0 else s[i + len(t):]
1476
+ if fn == "substring":
1477
+ return self.substring(e, node, position, size)
1478
+ if fn == "string-length":
1479
+ # UTF-16 units, as .NET counts
1480
+ return float(utf16_length(self.string_value(node) if not args
1481
+ else self.eval_string(args[0], node, position, size)))
1482
+ if fn == "normalize-space":
1483
+ s = self.string_value(node) if not args else self.eval_string(args[0], node, position, size)
1484
+ return " ".join(w for w in SPACE_RUNS.split(s) if w)
1485
+ if fn == "translate":
1486
+ s = self.eval_string(args[0], node, position, size)
1487
+ frm = self.eval_string(args[1], node, position, size)
1488
+ to = self.eval_string(args[2], node, position, size)
1489
+ mapping = {}
1490
+ for k, ch in enumerate(frm):
1491
+ if ch not in mapping:
1492
+ mapping[ch] = to[k] if k < len(to) else ""
1493
+ if not mapping:
1494
+ return s
1495
+ return "".join(mapping.get(ch, ch) for ch in s)
1496
+ if fn == "lower-case":
1497
+ return lower(self.eval_string(args[0], node, position, size))
1498
+ if fn == "upper-case":
1499
+ return upper(self.eval_string(args[0], node, position, size))
1500
+ if fn == "not":
1501
+ return not self.eval_bool(args[0], node, position, size)
1502
+ if fn == "true":
1503
+ return True
1504
+ if fn == "false":
1505
+ return False
1506
+ if fn == "boolean":
1507
+ return self.eval_bool(args[0], node, position, size)
1508
+ if fn == "number":
1509
+ if not args:
1510
+ return _string_to_number(self.string_value(node))
1511
+ return self.eval_number(args[0], node, position, size)
1512
+ if fn == "sum":
1513
+ total = 0.0
1514
+ for n in self.eval_nodes(args[0], node, position, size):
1515
+ total += _string_to_number(self.string_value(n))
1516
+ return total
1517
+ if fn == "floor":
1518
+ return _float_floor(self.eval_number(args[0], node, position, size))
1519
+ if fn == "ceiling":
1520
+ return _float_ceil(self.eval_number(args[0], node, position, size))
1521
+ if fn == "round":
1522
+ return _round(self.eval_number(args[0], node, position, size))
1523
+ raise XPathError(f"unknown XPath function {fn}")
1524
+
1525
+ def substring(self, e, node, position, size):
1526
+ """XPath 1.0: the chars at 1-based positions p with round(start) <= p < round(start) + round(length)."""
1527
+ args = e.args
1528
+ s = self.eval_string(args[0], node, position, size)
1529
+ start = _round(self.eval_number(args[1], node, position, size))
1530
+ to = start + _round(self.eval_number(args[2], node, position, size)) if len(args) > 2 else INF
1531
+ if start != start or to != to:
1532
+ return ""
1533
+ n = len(s)
1534
+ if start <= 1:
1535
+ first = 0
1536
+ elif start > n:
1537
+ first = n
1538
+ else:
1539
+ first = int(start) - 1
1540
+ if to >= n + 1:
1541
+ end = n
1542
+ elif to <= 1:
1543
+ end = 0
1544
+ else:
1545
+ end = int(to) - 1
1546
+ if end <= first:
1547
+ return ""
1548
+ return s[first:end]
1549
+
1550
+
1551
+ class XPathMatcher:
1552
+ """A compiled expression and its evaluation."""
1553
+
1554
+ __slots__ = ("expression", "expr")
1555
+
1556
+ def __init__(self, expression):
1557
+ self.expression = expression
1558
+ self.expr = compile_xpath(expression)
1559
+
1560
+ @property
1561
+ def is_node_set(self):
1562
+ return self.expr.type == TYPE_NODE_SET
1563
+
1564
+ def check_node_set(self):
1565
+ if self.expr.type != TYPE_NODE_SET:
1566
+ raise XPathError(f"the XPath {quote(self.expression)} gives a {TYPE_NAMES[self.expr.type]}, not tags; "
1567
+ "use xpath_value()")
1568
+
1569
+ @staticmethod
1570
+ def context(d, i):
1571
+ return _ROOT if i is None else of_tag(d, i)
1572
+
1573
+ def tags(self, d, i):
1574
+ """The indexes of the selected tags (elements and comments) in document order."""
1575
+ self.check_node_set()
1576
+ out = []
1577
+ for n in Evaluator(d).eval_expr(self.expr, self.context(d, i), 1, 1):
1578
+ if n.kind == ELEMENT or n.kind == COMMENT_NODE:
1579
+ out.append(n.tag)
1580
+ return out
1581
+
1582
+ def values(self, d, i):
1583
+ ev = Evaluator(d)
1584
+ result = ev.eval_expr(self.expr, self.context(d, i), 1, 1)
1585
+ if not isinstance(result, list):
1586
+ return [ev.to_str(result)]
1587
+ return [ev.string_value(n) for n in result]
1588
+
1589
+ def value(self, d, i):
1590
+ ev = Evaluator(d)
1591
+ result = ev.eval_expr(self.expr, self.context(d, i), 1, 1)
1592
+ if isinstance(result, list):
1593
+ return ev.string_value(result[0]) if result else None
1594
+ return ev.to_str(result)