- applyPredicates now computes position = isReverseAxis ? size - i : i + 1 for the 4 reverse axes.

- `getAncestors`/`getPreceding` rebuilt to yield strict document order (was closest-first / scrambled) so the reversed-position math lines up, and so parenthesized forms like `(preceding-sibling::*)[1]` — which per spec use plain document-order indexing since parens break axis-based numbering (resolves #3).

Author: leonelsanchesdasilva

src/expressions/step-expression.ts

@@ -180,12 +180,12 @@ export class XPathStep extends XPathExpression {
     }
 
     private getAncestors(node: any, includeSelf: boolean): any[] {
+        // Returned in document order (root first, closest ancestor last).
+        // Proximity numbering for the reverse axis is handled in applyPredicates().
         const result: any[] = [];
-        if (includeSelf) result.push(node);
-
-        let current = node.parentNode;
+        let current = includeSelf ? node : node.parentNode;
         while (current) {
-            result.push(current);
+            result.unshift(current);
             current = current.parentNode;
         }
         return result;
@@ -238,25 +238,29 @@ export class XPathStep extends XPathExpression {
     }
 
     private getPreceding(node: any): any[] {
+        // Returned in document order. Proximity numbering for the reverse
+        // axis is handled in applyPredicates().
         const result: any[] = [];
 
-        // Preceding siblings and their descendants (in reverse document order)
+        const unshiftSubtree = (n: any) => {
+            // n followed by its descendants is already document order;
+            // unshifting the whole block keeps farther subtrees ahead of closer ones.
+            result.unshift(n, ...this.getDescendants(n, false));
+        };
+
+        // Preceding siblings and their descendants
         let sibling = node.previousSibling;
         while (sibling) {
-            result.unshift(sibling);
-            const descendants = this.getDescendants(sibling, false);
-            result.unshift(...descendants);
+            unshiftSubtree(sibling);
             sibling = sibling.previousSibling;
         }
 
-        // Ancestors' preceding siblings
+        // Ancestors' preceding siblings and their descendants
         let ancestor = node.parentNode;
         while (ancestor) {
             sibling = ancestor.previousSibling;
             while (sibling) {
-                result.unshift(sibling);
-                const descendants = this.getDescendants(sibling, false);
-                result.unshift(...descendants);
+                unshiftSubtree(sibling);
                 sibling = sibling.previousSibling;
             }
             ancestor = ancestor.parentNode;
@@ -421,26 +425,39 @@ export class XPathStep extends XPathExpression {
         }
     }
 
+    /** Axes whose proximity position is counted in reverse document order (XPath 3.1 §2.5.1). */
+    private static readonly REVERSE_AXES = new Set<AxisType>([
+        'ancestor',
+        'ancestor-or-self',
+        'preceding',
+        'preceding-sibling',
+    ]);
+
     private applyPredicates(nodes: any[], context: any): any[] {
         let result = nodes;
+        // getNodesByAxis() always returns candidates in document order; for reverse
+        // axes the closest node to the context node is the *last* one in that order,
+        // so its proximity position (used by position()/numeric predicates) is 1.
+        const isReverseAxis = XPathStep.REVERSE_AXES.has(this.axis);
 
         for (const predicate of this.predicates) {
             const filtered: any[] = [];
             const size = result.length;
 
             for (let i = 0; i < result.length; i++) {
+                const position = isReverseAxis ? size - i : i + 1;
                 const predicateContext = {
                     ...context,
                     node: result[i],
-                    position: i + 1,
-                    size: size,
+                    position,
+                    size,
                 };
 
                 const predicateResult = predicate.evaluate(predicateContext);
 
                 // If predicate result is a number, it's a position test
                 if (typeof predicateResult === 'number') {
-                    if (predicateResult === i + 1) {
+                    if (predicateResult === position) {
                         filtered.push(result[i]);
                     }
                 } else if (this.toBoolean(predicateResult)) {

tests/location-path.test.ts

@@ -284,6 +284,96 @@ describe('Location Path and Step Expression Evaluation', () => {
         });
     });
 
+    describe('Reverse axis proximity position (GitHub issue #3)', () => {
+        // <fruit><banana><lady-finger-banana/></banana><apple/><pear/><kiwi/></fruit>
+        function buildFruitTree() {
+            const fruit = createNode('fruit');
+            const banana = createNode('banana', 1, fruit);
+            const ladyFinger = createNode('lady-finger-banana', 1, banana);
+            const apple = createNode('apple', 1, fruit);
+            const pear = createNode('pear', 1, fruit);
+            const kiwi = createNode('kiwi', 1, fruit);
+
+            banana.childNodes = [ladyFinger];
+            fruit.childNodes = [banana, apple, pear, kiwi];
+
+            banana.nextSibling = apple;
+            apple.previousSibling = banana;
+            apple.nextSibling = pear;
+            pear.previousSibling = apple;
+            pear.nextSibling = kiwi;
+            kiwi.previousSibling = pear;
+
+            return { fruit, banana, ladyFinger, apple, pear, kiwi };
+        }
+
+        it('preceding-sibling::*[1] returns the closest preceding sibling, not the first in document order', () => {
+            const { apple, pear } = buildFruitTree();
+
+            const ast = parse('preceding-sibling::*[1]') as XPathLocationPath;
+            const context: XPathContext = { node: pear, position: 1, size: 1 };
+            const result = ast.evaluate(context) as any[];
+
+            expect(result).toEqual([apple]);
+        });
+
+        it('(preceding-sibling::*)[1] still uses document order, since parenthesizing breaks axis-based numbering', () => {
+            const { banana, pear } = buildFruitTree();
+
+            const ast = parse('(preceding-sibling::*)[1]') as XPathLocationPath;
+            const context: XPathContext = { node: pear, position: 1, size: 1 };
+            const result = ast.evaluate(context) as any[];
+
+            expect(result).toEqual([banana]);
+        });
+
+        it('preceding::*[1] returns the closest preceding node in reverse document order', () => {
+            const { apple, pear } = buildFruitTree();
+
+            const ast = parse('preceding::*[1]') as XPathLocationPath;
+            const context: XPathContext = { node: pear, position: 1, size: 1 };
+            const result = ast.evaluate(context) as any[];
+
+            expect(result).toEqual([apple]);
+        });
+
+        it('preceding::* is returned in document order', () => {
+            const { banana, ladyFinger, apple, pear } = buildFruitTree();
+
+            const ast = parse('preceding::*') as XPathLocationPath;
+            const context: XPathContext = { node: pear, position: 1, size: 1 };
+            const result = ast.evaluate(context) as any[];
+
+            expect(result).toEqual([banana, ladyFinger, apple]);
+        });
+
+        it('ancestor::*[1] returns the closest ancestor', () => {
+            const grandparent = createNode('root');
+            const { fruit, pear } = buildFruitTree();
+            grandparent.childNodes = [fruit];
+            fruit.parentNode = grandparent;
+
+            const ast = parse('ancestor::*[1]') as XPathLocationPath;
+            const context: XPathContext = { node: pear, position: 1, size: 1 };
+            const result = ast.evaluate(context) as any[];
+
+            expect(result).toEqual([fruit]);
+        });
+
+        it('ancestor::* is returned in document order', () => {
+            const grandparent = createNode('root');
+            const { fruit, pear } = buildFruitTree();
+            grandparent.childNodes = [fruit];
+            fruit.parentNode = grandparent;
+
+            const ast = parse('ancestor::*') as XPathLocationPath;
+            const context: XPathContext = { node: pear, position: 1, size: 1 };
+            const result = ast.evaluate(context) as any[];
+
+            expect(result).toEqual([grandparent, fruit]);
+        });
+    });
+
     describe('Step Expression - Node Tests', () => {
         it('should match name node test', () => {
             const root = createNode('root');