Error using util:get-fragment-between in eXist-Db - xpath

Question

I'm trying convert a xml document, organized in divisions and paragraph, with page break and line breaks as milestones into a xml document that wraps pages and lines in page and line elements.
To do this I'm trying to use util:get-fragment-between.
To first get all the lines on a page into a fragment and then turn each line into a fragment.
The first step works, but in the second step, I get the following error org.exist.dom.memtree.ElementImpl cannot be cast to org.exist.dom.persistent.StoredNode which I do not understand.
Below is the xquery file and below that of an excerpt of the xml file I'm trying to convert.
xquery version "3.1";
let $doc := doc($docpath)
(: Build first fragment of containing only lines on page:)
let $begp-node := $doc//tei:pb[#n="15-v"]
let $endp-node := $doc//tei:pb[#n="16-r"]
let $p-fragment := util:get-fragment-between($begp-node, $endp-node, $make-fragment, $display-root-namespace)
let $p-node := util:parse($p-fragment)
(: so far so good, print out of p-node gives me an xml document with just the text on page 15-v :)
(: next step. here I attempt to build a fragment for each line in the newly created page fragment :)
let $lines := $p-node//tei:lb
for $line at $pos in $lines
let $make-fragment1 := true()
let $display-root-namespace1 := true()
let $beginning-node := $line
let $ending-node := $line/following::tei:lb[1]
let $fragment := util:get-fragment-between($beginning-node, $ending-node, $make-fragment1, $display-root-namespace1)
let $node := util:parse($fragment)
return $node
I would expect $node to be a new xml document that just contains the line fragment. But instead I get the error:
org.exist.dom.memtree.ElementImpl cannot be cast to org.exist.dom.persistent.StoredNode
Here is an excerpt of the original document:
<p>
<lb ed="#L"/>dilectio <choice>
<orig>dependant</orig>
<reg>dependant</reg>
</choice> causaliter a cognitione tamen quaelibet obiecti apprehensio vel cognitio
<lb ed="#L"/>cum voluntatis libertate sufficit dilectionem causare <g ref="#slash"/> prima
probatur quia si non sequitur quod dilec
<lb ed="#L"/>tio
<lb ed="#L"/>posset poni seu elici naturaliter a voluntate seclusa omni cognitione consequens
est falsum
<pb ed="#L" n="15-v"/>
<lb ed="#L" n="1"/> quia tunc voluntas posset diligere in infinitum contra <ref>
<name ref="#Augustine">augustinum</name> in libro 8 2 10 <title ref="#deTrinitate">de
trinitate</title>
</ref> patet consequentia quia positis omnibus causis ad productionem <sic>ad productionem</sic>
alicuius effectus re
<lb ed="#L" n="2"/>quisitis
<lb ed="#L" n="3"/>omni alio secluso talis effectus posset naturaliter poni in esse <g
ref="#slash"/>2a pars probatur quia
<lb ed="#L" n="4"/>quia si sola obiecti cognitio etc sequitur quod stante iudicio vel
apprehensione alicuius
<lb ed="#L" n="5"/>obiecti sub ratione <corr>
<del rend="strikethrough">boni</del>
<add place="inLine">mali</add>
</corr> seclusa omnia existentia vel apparentia bonitatis
<lb ed="#L" n="6"/>voluntas posset tale obiectum velle vel diligere consequentia nota sed
consequens est contra <ref>
<name ref="#Aristotle">philosophum</name>
</ref> et <ref>
<name ref="#Averroes">commentatorem</name>
<lb ed="#L" n="7"/>primo <name ref="#Ethics">ethicorum</name>
</ref> quia omnia bonum appetunt
<p xml:id="pgb1q2-d1e3692">
<g ref="#pilcrow"/>primum corollarium
<lb ed="#L" n="8"/>
Any advice is much appreciated.

Answer 1

This algorithm, although 3 times slower than the Java code, works in memory:
(:~ trim the XML from $nodes $start to $end
: The algorithm is
: 1) find all the ancestors of the start node - $startParents
: 2) find all the ancestors of the end node- $endParents
: 3) recursively, starting with the common top we create a new element which is a copy of the element being trimmed by
: 3.1 copying all attributes
: 3.2 there are four cases depending on the node and the start and end edge nodes of the tree
: a) left and right nodes are the same - nothing else to copy
: b) both nodes are in the node's children - trim the start one, copy the intervening children and trim the end one
: c) only the start node is in the node's children - trim this node and copy the following siblings
: d) only the end node is in the node's children - copy the preceding siblings and trim the node
: attributes (currently in the fb namespace since its not a TEI attribute) are added to trimmed nodes
: #param start - the element bounding the start of the subtree
: #param end - the element bounding the end of the subtree
:)
declare function fb:trim-node($start as node() ,$end as node()) {
let $startParents := $start/ancestor-or-self::*
let $endParents := $end/ancestor-or-self::*
let $top := $startParents[1]
return
fb:trim-node($top,subsequence($startParents,2),subsequence($endParents,2))
};
declare function fb:trim-node($node as node(), $start as node()*, $end as node()*) {
if (empty($start) and empty($end))
then $node (: leaf is untrimmed :)
else
let $startNode := $start[1]
let $endNode:= $end[1]
let $children := $node/node()
return
element {QName (namespace-uri($node), name($node))} { (: preserve the namespace :)
$node/#* , (: copy all the attributes :)
if ($startNode is $endNode) (: edge node is common :)
then fb:trim-node($startNode, subsequence($start,2),subsequence($end,2))
else
if ($startNode = $children and $endNode = $children) (: both in same subtree :)
then (fb:trim-node($startNode, subsequence($start,2),()), (: first the trimmed start node :)
(: then the siblings between start and end nodes :)
$startNode/following-sibling::node()
except $endNode/following-sibling::node()
except $endNode,
fb:trim-node($endNode, (), subsequence($end,2)) (: then the trimmed end node :)
)
else if ($startNode = $children) (: start node is in the children :)
then
( fb:trim-node($startNode, subsequence($start,2),()), (: first the trimmed start node :)
$startNode/following-sibling::node() (: then the following siblings :)
)
else if ($endNode = $children) (: end node is in the children :)
then
( $endNode/preceding-sibling::node(), (: the preceding siblings :)
fb:trim-node($endNode, (), subsequence($end,2)) (: then the trimmed end node :)
)
else ()
}
};
There is a comparison of four algorithms including the Java one, using a demo application original by joewiz here: http://kitwallace.co.uk/Book/set/fragment-between/page