leptris 1.9.302.0 → 1.9.304.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5007593d092ff504ec69d5682d450e15a65d6992f28a0684231be1fc4590e97
-  data.tar.gz: 8a4f49ee8964cd3d2f1ea2f758b82d282b6cd8e904a6a8609a54f9e71cc59b8b
+  metadata.gz: 1b942f5f5ee3ff31761b8fe6c5ddaac9245da364e2d32431760d297dcac8fd26
+  data.tar.gz: e0a6184e06d4557b5a4d4752305625e329d06104814158cd7d300bf26c0400bd
 SHA512:
-  metadata.gz: 99fafe4f1c4d8dd2538dbc38621c2eab52fbc287e9f83e86787e0dd43212cfbf4c3b39dbceaa513d97cf4db9e3ef4bcc8cb4c19defe5e297ec7b8d5c2591275a
-  data.tar.gz: b565409f1d6477dff43cf4c743d648bb77654be7d70403031ea1f16302abd628491f0c1b6c89d2cd90934371481223047c30e26cc63d84cc61be0a9b2ce90c09
+  metadata.gz: 36d2a9d04968b587d6656452490ca1d53fbf3d83fc25779d688f069c25ec3de2512b82af1f14c70407ec50327a267560aae1d0992f62e9fcf89fe6c506c872fc
+  data.tar.gz: 573eb433de3d251fb0fa2227a4f921651a45e5bc4160674077f6fc499844566364e55f0f49e4b74740d8f7893e0f577ee33c1cb7a999333f9ef37c2ab6d03f42

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [1.9.304.0] - 2026-10-05
+
+### Fixed
+
+- **Cross-document appends adopt by copy — the xpath.rb:39 crash
+  class (engine #1528, libleptris 1.9.304)**: the engine's four
+  splice seams (append/prepend/insert_before/insert_after) no
+  longer splice foreign-document pointers raw — a scratch-doc
+  node appended into a live tree then freed with its document
+  dangled every adopted node and detonated the next compiled-XPath
+  eval (the metanorma sectioned-cleanup crash). The binding now
+  completes the contract: cross-document appends return the
+  INSTALLED in-tree wrapper (add_child, append_children, children=,
+  prepend_child, add_previous_sibling, add_next_sibling, wrap),
+  the #178 namespace lift runs before the splice, and the source
+  original is removed after (the historical move semantics —
+  source loses the node). Same-document appends stay
+  pointer-identical on the native fast path. The wrap face moves
+  self into the INSTALLED wrapper. Adoption specs include the
+  scratch-free + compiled-XPath crash shape.
+
 ## [1.9.302.0] - 2026-10-05
 
 ### Engine sync (libleptris 1.9.293-1.9.302)

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.302"
+LIBLEPTRIS_VERSION = "1.9.304"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.302.0"
+  VERSION = "1.9.304.0"
 end

data/lib/leptris/xml/element.rb

@@ -419,6 +419,21 @@ class Leptris::XML::Element < Leptris::XML::Node
     # C-bound insert (TODO.perf/14): gates + predicate + version
     # bump + engine insert in one dispatch; Qnil = the child needs
     # the namespace lift — the full path below handles it.
+    # Cross-document nodes skip the fast path entirely (1.9.304,
+    # #1528): the engine deep-copies them at the splice, so the
+    # full path's lift must run FIRST and the source original is
+    # removed after (move semantics).
+    if node.document && !node.document.equal?(@document)
+      ensure_writable!
+      unless Leptris::XML::Element.skip_adoption_lift?(node)
+        Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+      end
+      Leptris::XML::FFI.check_status(
+        Leptris::XML::FFI.leptris_element_prepend_child(c_ptr, node.c_ptr))
+      Leptris::XML::Node.invalidate_cross_document!(node, @document)
+      node.parent&.remove_child(node)
+      return children.to_a.first
+    end
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
         @document, @c_address, node.c_ptr.address, 1).nil?
@@ -440,6 +455,20 @@ class Leptris::XML::Element < Leptris::XML::Node
     # C-bound insert (TODO.perf/14): gates + predicate + version
     # bump + engine insert in one dispatch; Qnil = the child needs
     # the namespace lift — the full path below handles it.
+    # Cross-document: full path first (lift + engine copy), then
+    # the source original is removed; returns the installed copy
+    # (self's new next sibling).
+    if node.document && !node.document.equal?(@document)
+      ensure_writable!
+      unless Leptris::XML::Element.skip_adoption_lift?(node)
+        Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+      end
+      Leptris::XML::FFI.check_status(
+        Leptris::XML::FFI.leptris_element_insert_after(c_ptr, node.c_ptr))
+      Leptris::XML::Node.invalidate_cross_document!(node, @document)
+      node.parent&.remove_child(node)
+      return self.next_sibling
+    end
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
         @document, @c_address, node.c_ptr.address, 2).nil?
@@ -461,6 +490,20 @@ class Leptris::XML::Element < Leptris::XML::Node
     # C-bound insert (TODO.perf/14): gates + predicate + version
     # bump + engine insert in one dispatch; Qnil = the child needs
     # the namespace lift — the full path below handles it.
+    # Cross-document: full path first (lift + engine copy), then
+    # the source original is removed; returns the installed copy
+    # (self's new previous sibling).
+    if node.document && !node.document.equal?(@document)
+      ensure_writable!
+      unless Leptris::XML::Element.skip_adoption_lift?(node)
+        Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+      end
+      Leptris::XML::FFI.check_status(
+        Leptris::XML::FFI.leptris_element_insert_before(c_ptr, node.c_ptr))
+      Leptris::XML::Node.invalidate_cross_document!(node, @document)
+      node.parent&.remove_child(node)
+      return self.previous_sibling
+    end
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
         @document, @c_address, node.c_ptr.address, 3).nil?
@@ -508,6 +551,9 @@ class Leptris::XML::Element < Leptris::XML::Node
       nodes.each { |n| add_child(n) }
       return
     end
+    cross = nodes.any? do |n|
+      n.document && !n.document.equal?(@document)
+    end
     if native_fast_children?
       addrs = nodes.map { |n| n.c_ptr.address }
       done = Leptris::XML::Native.append_binding_children(
@@ -516,14 +562,25 @@ class Leptris::XML::Element < Leptris::XML::Node
       if done >= nodes.size
         nodes.each do |n|
           Leptris::XML::Node.invalidate_cross_document!(n, @document)
+          remove_from_source_original(n) if cross
         end
-        return nodes
+        # 1.9.304 (#1528): foreign children were adopted by COPY —
+        # hand back the installed in-tree wrappers.
+        return cross ? children.to_a.last(nodes.size) : nodes
       end
       nodes[0, done].each do |n|
         Leptris::XML::Node.invalidate_cross_document!(n, @document)
+        remove_from_source_original(n) if cross
       end
       nodes = nodes[done..]
     end
+    if cross
+      nodes.each do |n|
+        append_installed(n)
+        remove_from_source_original(n)
+      end
+      return children.to_a.last(nodes.size)
+    end
     nodes.each { |n| add_child(n) }
     nodes
   end
@@ -565,9 +622,12 @@ class Leptris::XML::Element < Leptris::XML::Node
     # add_child moves self (unlinks from old parent first), so no explicit
     # remove_child needed — and trying to remove after the move corrupts
     # the C tree (libleptris silently handles non-child args badly).
-    add_next_sibling(wrapper)
-    wrapper.add_child(self)
-    self
+    # The wrapper may be cross-document (parsed into a scratch doc,
+    # 1.9.304 #1528) — add_next_sibling returns the INSTALLED copy;
+    # move self into THAT.
+    installed = add_next_sibling(wrapper)
+    installed.add_child(self)
+    installed
   end
 
   # Deep copy in a NEW document via Document.copy_of (the single
@@ -608,6 +668,13 @@ class Leptris::XML::Element < Leptris::XML::Node
     ensure_writable!
     case node_or_markup
     when Leptris::XML::Node
+      # Cross-document adoption (1.9.304, #1528): the engine
+      # deep-copies foreign nodes at the splice — the returned
+      # wrapper must be the INSTALLED copy, not the detached
+      # source. Route those through the re-resolving path.
+      cross = node_or_markup.document &&
+              !node_or_markup.document.equal?(@document)
+      return append_installed(node_or_markup) if cross
       # C-bound append (TODO.perf/08-09): one dispatch runs the
       # readonly/liveness gates, the provable no-op lift
       # predicate, the version bump, and the engine append. Qnil
@@ -659,6 +726,47 @@ class Leptris::XML::Element < Leptris::XML::Node
       raise ArgumentError, "add_child expects a Node or String, got #{node_or_markup.class}"
     end
   end
+  # Cross-document append (1.9.304, #1528): the engine deep-copies
+  # the foreign node at the splice, so the installed node is this
+  # element's LAST child — re-wrap it and return that. The binding
+  # keeps its historical MOVE semantics on top: namespaces are
+  # lifted BEFORE the copy (declarations survive), and the source
+  # original is removed after (the source loses the node, as
+  # every pre-304 caller observed).
+  def append_installed(node)
+    unless Leptris::XML::Element.skip_adoption_lift?(node)
+      Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
+    end
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_element_append_child(c_ptr, node.c_ptr))
+    Leptris::XML::Node.invalidate_cross_document!(node, @document)
+    remove_from_source_original(node)
+    last_installed
+  end
+  private :append_installed
+
+  # 1.9.304 (#1528): a foreign child appended to this document was
+  # adopted by COPY — remove the ORIGINAL from its source document
+  # (the binding's move semantics). The wrapper's @parent may be
+  # unset for lazily minted wrappers, so ask the ENGINE for the
+  # source parent and remove through a wrapped handle.
+  def remove_from_source_original(node)
+    return unless node.document && !node.document.equal?(@document)
+
+    srcp = Leptris::XML::FFI.leptris_node_parent(node.c_ptr)
+    return if srcp.nil? || srcp.null?
+
+    Leptris::XML::Node.wrap(srcp, node.document).remove_child(node)
+  end
+  private :remove_from_source_original
+
+  # The last child, wrapped fresh through the document's identity
+  # cache (bypasses any stale self-side wrapper of the same node).
+  def last_installed    kids = children.to_a
+    kids.last
+  end
+  private :last_installed
+
   # The markup-append face appends in fragment order; the added
   # nodes are this element's last +count+ children.
   def last_added(count)

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.302
+- libleptris v1.9.304
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,72 @@
 ## [Unreleased]
 
+## [1.9.304] - 2026-10-05
+
+### Fixed
+
+- **DOM: nodes from a different document are adopted by copy, never
+  spliced raw (#1528)** — `leptris_element_append_child`,
+  `prepend_child`, `insert_before` and `insert_after` accepted a
+  pointer from ANY document and spliced it in as-is. A node parsed
+  into a scratch document (the cleanup pipelines' replacement
+  markup) left the live tree holding nodes and text content from
+  the scratch pool; freeing that scratch document dangled every
+  adopted node, and the next native walk crashed — the
+  `leptris_xpath_compiled_eval` segfault in the metanorma
+  sectioned-cleanup path, same family as #358/#362/#371. The four
+  seams now adopt foreign nodes through `leptris_element_copy`
+  (the `set_root` adoption contract since #371). Same-document
+  moves stay pointer-identical and zero-copy; detached chains keep
+  their link-only contract; the mutation hot path reuses its
+  existing document resolution. RED spec under ASAN
+  (`CrossDocumentAdoption` in the mutation suite: splice a parsed
+  scratch root, free the scratch document, then compiled-XPath and
+  serialize the live tree).
+
+
+
+## [1.9.303] - 2026-10-05
+
+### Added
+
+- **XQuery: `fn:min`/`fn:max` coerce NaN** — any numeric NaN in the
+  input forces the NaN result; the comparison operators never select
+  it (`d > best` is false for NaN), so it is tracked explicitly
+  (K-SeqMAXFunc-16/27/28/31 and the MIN twins).
+- **XQuery: duration comparisons in `fn:min`/`fn:max`/`fn:sum`/
+  `fn:avg`** — `xs:yearMonthDuration` items compare by months,
+  `xs:dayTimeDuration` by seconds, through the shared duration
+  formatters (`max(1 to 10 months)` = `P10M`, `cbcl-max-015` =
+  `P1Y1M`). Duration results of the four aggregates carry their
+  atomic type, so `instance of xs:*Duration` now holds
+  (fn-sum-1/3/4/6, fn-max/min-4/6/7, K-SeqSUMFunc-30, fn-avg-3/5).
+- **XQuery: `fn:min`/`fn:max` over `xs:boolean`** — false < true,
+  and the result is a boolean, not a string (a string "false" would
+  read truthy at every assert-false site; cbcl-max-001, cbcl-min-002).
+
+### Fixed
+
+- **XQuery: `fn:sum#2` zero semantics** — the zero is the
+  EMPTY-sequence answer only, never an addend:
+  `sum((1 to 3), 17)` is 6 (was 23, fn-sum-12); an empty zero
+  leaves the empty result empty (`sum((), ())`, K-SeqSUMFunc-5);
+  a non-integer numeric zero adds back only for the empty sequence.
+  The libxslt suite (221/221) pins the XPath 1.0 side unchanged.
+- **instance of the duration types** — the `'d'`-marked member check
+  recovers the flavor from the lexical shape (months-only is
+  yearMonth; dayTime never spells months) and the scalar check
+  requires the matching atomic type; both branches sit ahead of the
+  `is_num_ty` catch-all that would otherwise swallow every
+  non-string/boolean/node base name.
+- **fn:sum atomization leak** — the duration prescan freed the
+  flattened array-carrier members' container but not the member
+  strings (Linux ASAN caught it: 10 bytes per `sum([1,2,3,4,5])`).
+- QT3 re-pins from one verified run: fn/avg 173→175, fn/max
+  167→176, fn/min 167→175, fn/sum 204→209 (+24 adopted cases;
+  total pins 1148 → 1172; 61/61 suites green).
+
+
+
 ## [1.9.302] - 2026-10-04
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.302
+    VERSION 1.9.304
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/leptris/dom/element_modify.c

@@ -273,6 +273,35 @@ LeptrisElement leptris_element_create_child(LeptrisElement parent, const char* n
     return elem;
 }
 
+/* #1528: a node arriving from a DIFFERENT document is adopted by
+ * deep copy (the set_root precedent, #371). Splicing the raw
+ * pointer leaves the tree holding nodes — and text content — from
+ * the source document's pool; when the caller frees that source
+ * (Document.parse scratch docs in the cleanup pipelines), every
+ * adopted node dangles and the next native walk detonates.
+ * Same-document moves and nodes with no resolvable document
+ * (detached chains, #540) stay zero-copy. Returns the node to
+ * splice, or NULL on copy failure. */
+static LeptrisNode* adopt_for_splice(LeptrisNode* node,
+                                     struct leptris_document* target) {
+    if (!node || !target) return node;
+    /* Type-safe walk to the chain top: get_document reads
+     * element-form fields and misreads non-element structs. */
+    LeptrisNode* top = node;
+    for (;;) {
+        LeptrisElement p = leptris_node_parent(top);
+        if (!p) break;
+        top = (LeptrisNode*)p;
+    }
+    if (top->type != LEPTRIS_NODE_TYPE_ELEMENT) return node;
+    struct leptris_document* src =
+        leptris_element_get_document((LeptrisElement)top);
+    if (!src || src == target) return node;
+    LeptrisElement copy =
+        leptris_element_copy((LeptrisElement)node, target);
+    return copy ? (LeptrisNode*)copy : NULL;
+}
+
 LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement child) {
     if (!parent || !child) return LEPTRIS_ERROR_NULL_ARG;
 
@@ -281,6 +310,11 @@ LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement
      * (twice here, once inside the internal for the tail cache). */
     struct leptris_document* doc = leptris_element_get_document(parent);
 
+    /* #1528: a foreign document's node is adopted by copy, never
+     * spliced raw. */
+    child = (LeptrisElement)adopt_for_splice((LeptrisNode*)child, doc);
+    if (!child) return LEPTRIS_ERROR_MEMORY;
+
     /* Call internal void function, assume success */
     leptris_element_append_child_internal_doc(parent, (LeptrisNode*)child, doc);
     leptris_element_invalidate_child_cache(parent);
@@ -302,6 +336,12 @@ LeptrisStatus leptris_element_append_child(LeptrisElement parent, LeptrisElement
 LeptrisStatus leptris_element_prepend_child(LeptrisElement parent, LeptrisElement child) {
     if (!parent || !child) return LEPTRIS_ERROR_NULL_ARG;
 
+    /* #1528: a foreign document's node is adopted by copy, never
+     * spliced raw. */
+    child = (LeptrisElement)adopt_for_splice(
+        (LeptrisNode*)child, leptris_element_get_document(parent));
+    if (!child) return LEPTRIS_ERROR_MEMORY;
+
     /* Call internal void function, assume success */
     leptris_element_prepend_child_internal(parent, (LeptrisNode*)child);
     leptris_element_invalidate_child_cache(parent);
@@ -337,6 +377,17 @@ LeptrisStatus leptris_element_insert_before(LeptrisElement sibling, LeptrisEleme
      * sequence (libxml2 xmlAddPrevSibling semantics for unlinked
      * nodes; the flat next-sibling layout needs no extra state). */
     LeptrisElement parent = leptris_node_parent(sibling_ptr);
+
+    /* #1528: a foreign document's node is adopted by copy, never
+     * spliced raw. The target document resolves from the attached
+     * parent (type-safe); a detached sibling stays zero-copy — the
+     * chain-link mode below keeps its contract. */
+    new_node_ptr = adopt_for_splice(
+        new_node_ptr,
+        parent ? leptris_element_get_document(parent) : NULL);
+    if (!new_node_ptr) return LEPTRIS_ERROR_MEMORY;
+    new_node = (LeptrisElement)new_node_ptr;
+
     if (!parent) {
         if (leptris_node_parent(new_node_ptr)) {
             leptris_node_unlink(new_node_ptr);
@@ -432,6 +483,17 @@ LeptrisStatus leptris_element_insert_after(LeptrisElement sibling, LeptrisElemen
     }
 
     LeptrisElement parent = leptris_node_parent(sibling_ptr);
+
+    /* #1528: a foreign document's node is adopted by copy, never
+     * spliced raw. The target document resolves from the attached
+     * parent (type-safe); a detached sibling stays zero-copy — the
+     * chain-link mode below keeps its contract. */
+    new_node_ptr = adopt_for_splice(
+        new_node_ptr,
+        parent ? leptris_element_get_document(parent) : NULL);
+    if (!new_node_ptr) return LEPTRIS_ERROR_MEMORY;
+    new_node = (LeptrisElement)new_node_ptr;
+
     if (!parent) {
         /* Issue #540: detached sibling — link-only append after it. */
         if (leptris_node_parent(new_node_ptr)) {

data/vendor-src/libleptris/src/leptris/xpath/evaluator_operators.c

@@ -2825,6 +2825,24 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                         m = tag == (int)LEPTRIS_NODE_TEXT && !is_num_member;
                     } else if (is_bool_ty) {
                         m = 0;
+                    } else if (strcmp(base, "xs:yearMonthDuration") == 0 ||
+                               strcmp(base, "xs:dayTimeDuration") == 0) {
+                        /* duration members ride the 'd' marker; a
+                         * months-only lexical is yearMonth (dayTime
+                         * never spells months) — kept ahead of the
+                         * is_num_ty catch-all, which would swallow
+                         * them */
+                        m = mc && mc[0] == '\x03' && mc[1] == 'd';
+                        if (m) {
+                            double mv, sv;
+                            int months_only =
+                                leptris_dur_try_months(mc + 2, &mv);
+                            m = base[3] == 'y'
+                                    ? months_only
+                                    : (!months_only &&
+                                       leptris_dur_try_seconds(mc + 2,
+                                                               &sv));
+                        }
                     } else if (is_num_ty) {
                         m = is_num_member;
                         if (m && is_int_ty && mc) {
@@ -2840,6 +2858,17 @@ struct leptris_xpath_result* evaluate_operator(XPathContext* ctx,
                  * occurrence indicator admits it. */
                 if (is_string_ty) m = v->type == XPATH_RESULT_STRING;
                 else if (is_bool_ty) m = v->type == XPATH_RESULT_BOOLEAN;
+                else if (strcmp(base, "xs:yearMonthDuration") == 0 ||
+                         strcmp(base, "xs:dayTimeDuration") == 0) {
+                    /* duration-typed results carry their atomic
+                     * type from the constructor/aggregator; a plain
+                     * string is not a duration (fn-avg-3/5,
+                     * fn-max/min-4/6) — kept ahead of the is_num_ty
+                     * catch-all, which would swallow them */
+                    m = v->type == XPATH_RESULT_STRING &&
+                        v->atomic_type &&
+                        strcmp(v->atomic_type, base) == 0;
+                }
                 else if (is_num_ty) {
                     m = v->type == XPATH_RESULT_NUMBER;
                     if (m && is_int_ty)

data/vendor-src/libleptris/src/leptris/xpath/functions.c

@@ -2234,17 +2234,24 @@ static struct leptris_xpath_result* xpath_func_sum(XPathContext* context,
         return NULL;
     }
 
-    /* fn:sum#2 zero: the value returned for the empty sequence.
-     * XQuery-only surface; the numeric zero is the supported form
-     * (duration zeros need duration algebra). */
+    /* fn:sum#2 zero: the value returned for the empty sequence —
+     * never an addend (fn-sum-12: sum((1 to 3), 17) = 6). An EMPTY
+     * zero leaves the empty result empty (K-SeqSUMFunc-5). */
     double zero = 0.0;
     int has_zero = 0;
+    int zero_is_empty = 0;
     long long isum_seed = 0;
     int zero_non_int = 0;
     char* zero_lex = NULL;  /* owned: the zero's lexical form */
     if (arg_count == 2) {
         struct leptris_xpath_result* zr = xpath_evaluate(context, args[1]);
         if (!zr) return NULL;
+        if (zr->type == XPATH_RESULT_NODESET &&
+            (!zr->value.nodeset_value ||
+             xpath_nodeset_count(zr->value.nodeset_value) == 0)) {
+            zero_is_empty = 1;
+            xpath_result_free(zr);
+        } else {
         char* zs = result_to_string(zr);
         xpath_result_free(zr);
         if (!zs) return NULL;
@@ -2271,12 +2278,13 @@ static struct leptris_xpath_result* xpath_func_sum(XPathContext* context,
             if (!zero_lex) LEPTRIS_FREE(zs);
             has_zero = 1;
         }
+        }
     }
 
     struct leptris_xpath_result* arg_result = xpath_evaluate(context, args[0]);
     if (!arg_result) return NULL;
 
-    double sum = zero;
+    double sum = 0;
     int has_nan = 0;
     size_t count = 0;
     /* int64-exact accumulation: integer sums past 2^53 lose digits
@@ -2293,6 +2301,74 @@ static struct leptris_xpath_result* xpath_func_sum(XPathContext* context,
         XPathNodeSet* nodeset = arg_result->value.nodeset_value;
         if (nodeset) {
             count = xpath_nodeset_count(nodeset);
+            /* Duration sums take their own channels: all-months or
+             * all-seconds items total through the shared duration
+             * formatters (fn-sum-3, fn-sum-6). This must precede
+             * the numeric accumulation — a "P1D" item is not a
+             * number, and the numeric path would force NaN. */
+            if (count > 0) {
+                int all_ymd = 1, all_dtd = 1;
+                double mtot = 0, stot = 0;
+                for (size_t i = 0;
+                     i < count && (all_ymd || all_dtd); i++) {
+                    void* node = xpath_nodeset_get(nodeset, i);
+                    const char* mc = NULL;
+                    if ((int)XPATH_NODE_TYPE(node) == LEPTRIS_NODE_TEXT)
+                        mc = ((XPathTextNode*)node)->content;
+                    char** am = NULL;
+                    size_t an = 0;
+                    char* single = NULL;
+                    char** vals = NULL;
+                    size_t nv = 0;
+                    if (mc && mc[0] == '\x03' && mc[1] == 'M' &&
+                        xpath_array_members_of(mc, &am, &an)) {
+                        vals = am;
+                        nv = an;
+                    } else {
+                        single = get_node_text(node);
+                        vals = &single;
+                        nv = single ? 1 : 0;
+                    }
+                    for (size_t j = 0; j < nv; j++) {
+                        double mv, sv;
+                        if (!leptris_dur_try_months(vals[j], &mv))
+                            all_ymd = 0;
+                        else
+                            mtot += mv;
+                        if (!leptris_dur_try_seconds(vals[j], &sv))
+                            all_dtd = 0;
+                        else
+                            stot += sv;
+                    }
+                    if (am) {
+                        for (size_t j = 0; j < an; j++) free(am[j]);
+                        free(am);
+                    }
+                    if (single) LEPTRIS_FREE(single);
+                }
+                if (all_ymd || all_dtd) {
+                    char dbuf[64];
+                    struct leptris_xpath_result* dr =
+                        xpath_result_new(XPATH_RESULT_STRING);
+                    if (dr) {
+                        if (all_ymd)
+                            leptris_dur_format_months(mtot, dbuf,
+                                                      sizeof dbuf);
+                        else
+                            leptris_dur_format(stot, dbuf,
+                                               sizeof dbuf);
+                        dr->value.string_value = leptris_strdup(dbuf);
+                        /* the result is a duration: typed for
+                         * instance of (fn-sum-1/4) */
+                        dr->atomic_type = all_ymd
+                            ? "xs:yearMonthDuration"
+                            : "xs:dayTimeDuration";
+                    }
+                    xpath_result_free(arg_result);
+                    LEPTRIS_FREE(zero_lex);
+                    return dr;
+                }
+            }
             for (size_t i = 0; i < count; i++) {
                 void* node = xpath_nodeset_get(nodeset, i);
                 const char* mc = NULL;
@@ -2373,12 +2449,31 @@ static struct leptris_xpath_result* xpath_func_sum(XPathContext* context,
     if (has_nan) {
         LEPTRIS_FREE(zero_lex);
         result->value.number_value = NAN;
-    } else if (all_int && !zero_non_int && !iovf && (count > 0 || has_zero)) {
+    } else if (count == 0 && zero_is_empty) {
+        /* sum($s, ()) keeps the empty result empty */
+        LEPTRIS_FREE(zero_lex);
+        xpath_result_free(result);
+        result = xpath_result_new(XPATH_RESULT_NODESET);
+        if (result) {
+            result->value.nodeset_value = xpath_nodeset_new();
+            if (!result->value.nodeset_value) {
+                xpath_result_free(result);
+                result = NULL;
+            }
+        }
+        return result;
+    } else if (all_int && !zero_non_int && !iovf && count > 0) {
+        /* the zero is the empty-sequence answer only — a non-empty
+         * sum never includes it (fn-sum-12: sum((1 to 3), 17)=6) */
         result->is_int = 1;
-        result->int_value = isum + isum_seed;
+        result->int_value = isum;
         /* eq/boolean compare through the double field even when the
          * int64 channel carries the exact value. */
-        result->value.number_value = (double)(isum + isum_seed);
+        result->value.number_value = (double)isum;
+    } else if (count == 0 && has_zero && all_int && !zero_non_int) {
+        result->is_int = 1;
+        result->int_value = isum_seed;
+        result->value.number_value = (double)isum_seed;
     } else if (count == 0 && zero_lex) {
         xpath_result_free(result);
         result = xpath_result_new(XPATH_RESULT_STRING);
@@ -2392,7 +2487,10 @@ static struct leptris_xpath_result* xpath_func_sum(XPathContext* context,
          * the adapter, not here). */
         result->value.number_value = 0;
     } else {
-        result->value.number_value = sum;
+        /* the zero only answers the empty sequence; add it back
+         * just there (sum((), 3.5) = 3.5) */
+        result->value.number_value =
+            sum + ((count == 0 && has_zero) ? zero : 0.0);
         if (all_float && count > 0) result->atomic_type = "xs:float";
     }
     LEPTRIS_FREE(zero_lex);

data/vendor-src/libleptris/src/leptris/xpath/functions_ext31.c

@@ -762,6 +762,35 @@ static struct leptris_xpath_result* fn_avg_min_max(XPathContext* ctx,
                 leptris_dur_format_months(tot / (double)cnt, mbuf,
                                           sizeof mbuf);
                 out->value.string_value = leptris_strdup(mbuf);
+                out->atomic_type = "xs:yearMonthDuration";
+            }
+            free_items(items, cnt);
+            return out;
+        }
+    }
+    /* min/max over yearMonthDuration items compare months and spell
+     * canonically through the months formatter; the result is
+     * duration-typed (fn-max-6/7, fn-min-6/7, cbcl-max-015). */
+    if (which >= 2) {
+        double m0;
+        int all_ymd = 1;
+        for (size_t k = 0; k < cnt && all_ymd; k++)
+            if (!leptris_dur_try_months(items[k], &m0)) all_ymd = 0;
+        if (all_ymd && cnt > 0) {
+            double bm = 0;
+            for (size_t k = 0; k < cnt; k++) {
+                double mk;
+                leptris_dur_try_months(items[k], &mk);
+                if (k == 0 || (which == 2 && mk < bm) ||
+                    (which == 3 && mk > bm)) bm = mk;
+            }
+            char mbuf[64];
+            xpath_result_free(out);
+            out = xpath_result_new(XPATH_RESULT_STRING);
+            if (out) {
+                leptris_dur_format_months(bm, mbuf, sizeof mbuf);
+                out->value.string_value = leptris_strdup(mbuf);
+                out->atomic_type = "xs:yearMonthDuration";
             }
             free_items(items, cnt);
             return out;
@@ -796,13 +825,39 @@ static struct leptris_xpath_result* fn_avg_min_max(XPathContext* ctx,
                     leptris_dur_format(tot / (double)cnt, dbuf,
                                        sizeof dbuf);
                     out->value.string_value = leptris_strdup(dbuf);
+                    out->atomic_type = "xs:dayTimeDuration";
                 }
                 free_items(items, cnt);
                 return out;
             }
             out = xpath_result_new(XPATH_RESULT_STRING);
-            if (out)
+            if (out) {
                 out->value.string_value = leptris_strdup(items[bi]);
+                out->atomic_type = "xs:dayTimeDuration";
+            }
+            free_items(items, cnt);
+            return out;
+        }
+    }
+    /* min/max over xs:boolean: false < true, and the result is a
+     * boolean — a string "false" would EBV truthy at every
+     * assert-false site (cbcl-max-001, cbcl-min-002). */
+    if (which >= 2) {
+        int all_bool = 1, any_true = 0, all_true = 1;
+        for (size_t k = 0; k < cnt && all_bool; k++) {
+            if (strcmp(items[k], "true") == 0) {
+                any_true = 1;
+            } else if (strcmp(items[k], "false") != 0) {
+                all_bool = 0;
+            } else {
+                all_true = 0;
+            }
+        }
+        if (all_bool && cnt > 0) {
+            xpath_result_free(out);
+            out = xpath_result_new(XPATH_RESULT_BOOLEAN);
+            if (out) out->value.boolean_value =
+                (which == 3) ? any_true : all_true;
             free_items(items, cnt);
             return out;
         }
@@ -813,12 +868,19 @@ static struct leptris_xpath_result* fn_avg_min_max(XPathContext* ctx,
     /* F&O: max/min over non-numeric items (xs:string, xs:anyURI)
      * compare in codepoint order and return the extreme ITEM. */
     int all_str = (cnt > 0);
+    /* Any numeric NaN in the input forces the NaN result — the
+     * comparison operators never select it (d > best is false for
+     * NaN), so it is tracked explicitly (K-SeqMAXFunc-27). */
+    int has_nan = 0;
     for (size_t k = 0; k < cnt; k++) {
         char* end = NULL;
         double d = strtod(items[k], &end);
         int is_num = items[k][0] != '\0' && end != items[k] &&
                      *end == '\0';
-        if (is_num) all_str = 0;
+        if (is_num) {
+            all_str = 0;
+            if (isnan(d)) has_nan = 1;
+        }
         if (items[k][0] == '\0') d = 0;   /* empty string -> NaN in spec; treat 0 */
         acc += d;
         if (first) { best = d; first = 0; }
@@ -826,6 +888,7 @@ static struct leptris_xpath_result* fn_avg_min_max(XPathContext* ctx,
         else if (which == 3 && d > best) best = d;   /* max */
         numeric++;
     }
+    if (which >= 2 && has_nan) best = NAN;
     if (which >= 2 && all_str) {
         size_t bi = 0;
         for (size_t k = 1; k < cnt; k++) {

data/vendor-src/libleptris/test/abi/test_dom_mutation_bugs.cpp

@@ -208,3 +208,130 @@ TEST(InsertNonElement, InsertTextMiddle) {
     EXPECT_EQ(childNodeTypes(root), "E,T,E");
     leptris_document_free(doc);
 }
+
+// ============================================================================
+// #1528: a node arriving from a DIFFERENT document was spliced in as a
+// raw pointer. The splice target keeps nodes (and their text content)
+// from the source document's pool — when the caller frees that source
+// (Document.parse scratch docs), every adopted node dangles and the
+// next native walk detonates. The repro family: SAX-built tree, moxml
+// in-place cleanup (replace/move/insert), then compiled XPath eval.
+// The fix adopts cross-document nodes by deep copy (the set_root
+// precedent, #371); same-document moves stay zero-copy.
+// ============================================================================
+
+namespace {
+
+// Splice scratch_root into live per fn, free the scratch document,
+// then exercise the tree the way the cleanup phase does: a compiled
+// XPath evaluation followed by serialization.
+static void splice_free_eval(
+    void (*splice)(LeptrisDocument live, LeptrisElement target,
+                   LeptrisElement scratch_root),
+    const char* expected_xml) {
+    LeptrisDocument live = Parse("<r><a/><b/></r>");
+    ASSERT_NE(live, nullptr);
+    LeptrisDocument scratch = Parse("<x>replacement</x>");
+    ASSERT_NE(scratch, nullptr);
+
+    LeptrisElement target = leptris_document_root(live);
+    ASSERT_NE(target, nullptr);
+    LeptrisElement scratch_root = leptris_document_root(scratch);
+    ASSERT_NE(scratch_root, nullptr);
+
+    splice(live, target, scratch_root);
+
+    // The scratch document dies here — exactly the moxml lifecycle
+    // where the parsed fragment's document drops out of scope.
+    leptris_document_free(scratch);
+
+    // Detonation site from the issue: compiled XPath over the
+    // mutated tree.
+    LeptrisXPathCompiled c = leptris_xpath_compile("count(//x)");
+    ASSERT_NE(c, nullptr);
+    LeptrisXPathResult r = leptris_xpath_compiled_eval(c, live, nullptr);
+    ASSERT_NE(r, nullptr);
+    EXPECT_EQ(leptris_xpath_result_number(r), 1.0);
+    leptris_xpath_result_free(r);
+    leptris_xpath_compiled_free(c);
+
+    LeptrisXPathCompiled s = leptris_xpath_compile("string(//x)");
+    ASSERT_NE(s, nullptr);
+    LeptrisXPathResult sr = leptris_xpath_compiled_eval(s, live, nullptr);
+    ASSERT_NE(sr, nullptr);
+    char* text = leptris_xpath_result_string(sr);
+    ASSERT_NE(text, nullptr);
+    EXPECT_STREQ(text, "replacement");
+    leptris_free_string(text);
+    leptris_xpath_result_free(sr);
+    leptris_xpath_compiled_free(s);
+
+    // Serialization walks the same spine the axes do.
+    char* xml = leptris_document_serialize(live, NULL);
+    ASSERT_NE(xml, nullptr);
+    EXPECT_STREQ(xml, expected_xml);
+    leptris_free_string(xml);
+
+    leptris_document_free(live);
+}
+
+}  // namespace
+
+TEST(CrossDocumentAdoption, InsertAfterSurvivesScratchFree) {
+    splice_free_eval([](LeptrisDocument, LeptrisElement target,
+                        LeptrisElement scratch_root) {
+        LeptrisElement a = leptris_element_first_child_any(target);
+        ASSERT_NE(a, nullptr);
+        EXPECT_EQ(leptris_element_insert_after(a, scratch_root),
+                  LEPTRIS_OK);
+    },
+    "<r><a/><x>replacement</x><b/></r>");
+}
+
+TEST(CrossDocumentAdoption, InsertBeforeSurvivesScratchFree) {
+    splice_free_eval([](LeptrisDocument, LeptrisElement target,
+                        LeptrisElement scratch_root) {
+        LeptrisElement b = leptris_element_first_child_any(target);
+        ASSERT_NE(b, nullptr);
+        b = leptris_element_next_sibling_any(b);
+        ASSERT_NE(b, nullptr);
+        EXPECT_EQ(leptris_element_insert_before(b, scratch_root),
+                  LEPTRIS_OK);
+    },
+    "<r><a/><x>replacement</x><b/></r>");
+}
+
+TEST(CrossDocumentAdoption, AppendChildSurvivesScratchFree) {
+    splice_free_eval([](LeptrisDocument, LeptrisElement target,
+                        LeptrisElement scratch_root) {
+        EXPECT_EQ(leptris_element_append_child(target, scratch_root),
+                  LEPTRIS_OK);
+    },
+    "<r><a/><b/><x>replacement</x></r>");
+}
+
+TEST(CrossDocumentAdoption, PrependChildSurvivesScratchFree) {
+    splice_free_eval([](LeptrisDocument, LeptrisElement target,
+                        LeptrisElement scratch_root) {
+        EXPECT_EQ(leptris_element_prepend_child(target, scratch_root),
+                  LEPTRIS_OK);
+    },
+    "<r><x>replacement</x><a/><b/></r>");
+}
+
+TEST(CrossDocumentAdoption, ReplaceKeepsSameDocumentMoveZeroCopy) {
+    // A same-document move must stay the raw splice (identity and
+    // pointer preserved) — the adoption path is cross-document only.
+    LeptrisDocument doc = Parse("<r><a/><b/><c/></r>");
+    ASSERT_NE(doc, nullptr);
+    LeptrisElement root = leptris_document_root(doc);
+    LeptrisElement a = leptris_element_first_child_any(root);
+    LeptrisElement b = leptris_element_next_sibling_any(a);
+
+    EXPECT_EQ(leptris_element_insert_after(a, b), LEPTRIS_OK);
+    char* xml = leptris_document_serialize(doc, NULL);
+    ASSERT_NE(xml, nullptr);
+    EXPECT_STREQ(xml, "<r><a/><b/><c/></r>");
+    leptris_free_string(xml);
+    leptris_document_free(doc);
+}

data/vendor-src/libleptris/test/xquery/test_qt3.cpp

@@ -949,16 +949,8 @@ TEST(Qt3Subset, FnAbs) {
                  "fn-abs-1"});
 }
 TEST(Qt3Subset, FnAvg) {
-    run_test_set("fn/avg.xml", {}, 173, {},
-                 {"cbcl-avg-008",
-                 "fn-avg-3",
-                 "fn-avg-5",
-                 "fn-avg-mix-args-012",
-                 "fn-avg-mix-args-013",
-                 "fn-avg-mix-args-014",
-                 "fn-avg-mix-args-015",
-                 "fn-avgintg2args-2",
-                 "fn-avgintg2args-4"});
+    run_test_set("fn/avg.xml", {}, 175, {},
+                 {"cbcl-avg-008", "fn-avgintg2args-2", "fn-avgintg2args-4", "fn-avg-mix-args-012", "fn-avg-mix-args-013", "fn-avg-mix-args-014", "fn-avg-mix-args-015"});
 }
 TEST(Qt3Subset, FnCeiling) {
     run_test_set("fn/ceiling.xml", {}, 39, {},
@@ -973,29 +965,12 @@ TEST(Qt3Subset, FnFloor) {
                  "fn-floorflt1args-3"});
 }
 TEST(Qt3Subset, FnMax) {
-    run_test_set("fn/max.xml", {}, 167, {},
-                 {"K-SeqMAXFunc-16",
-                 "K-SeqMAXFunc-27",
-                 "K-SeqMAXFunc-28",
-                 "K-SeqMAXFunc-31",
-                 "cbcl-max-001",
-                 "cbcl-max-015",
-                 "fn-max-10",
-                 "fn-max-4",
-                 "fn-max-6",
-                 "fn-max-7"});
+    run_test_set("fn/max.xml", {}, 176, {},
+                 {"fn-max-10"});
 }
 TEST(Qt3Subset, FnMin) {
-    run_test_set("fn/min.xml", {}, 167, {},
-                 {"K-SeqMINFunc-16",
-                 "K-SeqMINFunc-27",
-                 "K-SeqMINFunc-28",
-                 "K-SeqMINFunc-31",
-                 "cbcl-min-002",
-                 "fn-min-10",
-                 "fn-min-4",
-                 "fn-min-6",
-                 "fn-min-7"});
+    run_test_set("fn/min.xml", {}, 175, {},
+                 {"fn-min-10"});
 }
 TEST(Qt3Subset, FnRound) { run_test_set("fn/round.xml", {}, 220); }
 TEST(Qt3Subset, FnRoundHalfToEven) {
@@ -1008,13 +983,8 @@ TEST(Qt3Subset, FnRoundHalfToEven) {
                  "cbcl-round-half-to-even-012"});
 }
 TEST(Qt3Subset, FnSum) {
-    run_test_set("fn/sum.xml", {}, 204, {},
-                 {"K-SeqSUMFunc-30",
-                 "K-SeqSUMFunc-5",
-                 "fn-sum-12",
-                 "fn-sum-3",
-                 "fn-sum-6",
-                 "fn-sum-8"});
+    run_test_set("fn/sum.xml", {}, 209, {},
+                 {"fn-sum-8"});
 }
 TEST(Qt3Subset, FnApply) {
     run_test_set("fn/apply.xml", {}, 5, {},

data/vendor-src/libleptris/test/xquery/test_xquery.cpp

@@ -244,6 +244,91 @@ TEST(XQueryCore, ArrayAtomizedAggregates) {
     leptris_document_free(doc);
 }
 
+TEST(XQueryCore, MinMaxNaNCoercion) {
+    LeptrisDocument doc = leptris_parse_string("<r/>", 4, nullptr);
+    ASSERT_NE(doc, nullptr);
+    EXPECT_EQ(seq_string(doc, "string(max((1, xs:double(\"NaN\"))))"),
+              "NaN");
+    EXPECT_EQ(seq_string(doc, "string(max((3, xs:float(\"NaN\"))))"),
+              "NaN");
+    EXPECT_EQ(seq_string(doc,
+        "string(max((xs:float(-3), xs:untypedAtomic(\"3\"),"
+        " xs:double(\"NaN\"))))"), "NaN");
+    EXPECT_EQ(seq_string(doc, "string(min((2, xs:double(\"NaN\"))))"),
+              "NaN");
+    leptris_document_free(doc);
+}
+
+TEST(XQueryCore, MinMaxDurationTyping) {
+    LeptrisDocument doc = leptris_parse_string("<r/>", 4, nullptr);
+    ASSERT_NE(doc, nullptr);
+    EXPECT_EQ(seq_string(doc,
+        "max((xs:yearMonthDuration(\"P1Y\"),"
+        " xs:yearMonthDuration(\"P1M\")))"
+        " instance of xs:yearMonthDuration"), "true");
+    EXPECT_EQ(seq_string(doc,
+        "max(for $x in 1 to 10 return"
+        " xs:yearMonthDuration(concat(\"P\",$x,\"M\")))"), "P10M");
+    EXPECT_EQ(seq_string(doc,
+        "min(for $x in 1 to 10 return"
+        " xs:yearMonthDuration(concat(\"P\",$x,\"M\")))"), "P1M");
+    EXPECT_EQ(seq_string(doc,
+        "max((xs:dayTimeDuration(\"P1D\"),"
+        " xs:dayTimeDuration(\"PT2H\"))) instance of xs:dayTimeDuration"),
+        "true");
+    EXPECT_EQ(seq_string(doc,
+        "min((xs:dayTimeDuration(\"P1D\"),"
+        " xs:dayTimeDuration(\"PT2H\"))) instance of xs:dayTimeDuration"),
+        "true");
+    EXPECT_EQ(seq_string(doc,
+        "avg((xs:dayTimeDuration(\"P1D\"),"
+        " xs:dayTimeDuration(\"PT2H\"))) instance of xs:dayTimeDuration"),
+        "true");
+    EXPECT_EQ(seq_string(doc,
+        "avg((xs:yearMonthDuration(\"P1Y\"),"
+        " xs:yearMonthDuration(\"P1M\"))) instance of xs:yearMonthDuration"),
+        "true");
+    leptris_document_free(doc);
+}
+
+TEST(XQueryCore, MinMaxBooleans) {
+    LeptrisDocument doc = leptris_parse_string("<r/>", 4, nullptr);
+    ASSERT_NE(doc, nullptr);
+    /* the result is a BOOLEAN: assert-false EBVs it, and a string
+     * "false" would EBV truthy (cbcl-max-001) */
+    EXPECT_EQ(seq_string(doc,
+        "max((false(), false(), false())) instance of xs:boolean"),
+        "true");
+    EXPECT_EQ(seq_string(doc, "max((false(), false(), false()))"),
+              "false");
+    EXPECT_EQ(seq_string(doc, "max((true(), false()))"), "true");
+    EXPECT_EQ(seq_string(doc, "min((true(), false(), true()))"), "false");
+    EXPECT_EQ(seq_string(doc, "min((true(), true()))"), "true");
+    leptris_document_free(doc);
+}
+
+TEST(XQueryCore, SumZeroAndDurations) {
+    LeptrisDocument doc = leptris_parse_string("<r/>", 4, nullptr);
+    ASSERT_NE(doc, nullptr);
+    /* fn:sum#2: the zero is the EMPTY-sequence answer only, never
+     * an addend (fn-sum-12) */
+    EXPECT_EQ(seq_string(doc, "sum((1 to 3), 17)"), "6");
+    EXPECT_EQ(seq_string(doc, "sum((), 17)"), "17");
+    /* an empty zero leaves the empty result empty (K-SeqSUMFunc-5) */
+    EXPECT_EQ(seq_string(doc, "empty(sum((), ()))"), "true");
+    EXPECT_EQ(seq_string(doc,
+        "sum(for $x in 1 to 10 return"
+        " xs:yearMonthDuration(concat(\"P\",$x,\"M\")))"), "P4Y7M");
+    EXPECT_EQ(seq_string(doc,
+        "sum(for $x in 1 to 10 return"
+        " xs:dayTimeDuration(concat(\"PT\",$x,\"H\")))"), "P2DT7H");
+    EXPECT_EQ(seq_string(doc,
+        "sum((xs:yearMonthDuration(\"P20Y\"),"
+        " xs:yearMonthDuration(\"P10M\")))"
+        " eq xs:yearMonthDuration(\"P250M\")"), "true");
+    leptris_document_free(doc);
+}
+
 TEST(XQueryCore, OrderByDescending) {
     LeptrisDocument doc = leptris_parse_string(kBooks, strlen(kBooks),
                                                nullptr);

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.302",
+  "version": "1.9.304",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.302.0
+  version: 1.9.304.0
 platform: ruby
 authors:
 - Ribose Inc.