leptris 1.9.273.1 → 1.9.277.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47fcca29c1cb0aacea1ff5027999e599246075f64cc810075df396e1d4e38e42
-  data.tar.gz: df9e0dc01a033ac4bc77664871ea3d68d93659dfc4711f4ea6bff4a26296a767
+  metadata.gz: 6ed9c7b8afac75281839aedc850f425345d336f7893313c46a4b98fbda74118e
+  data.tar.gz: 939f5e15e2d829b2126ad81702d2d1cd09943b60047878722ad4f80992db416c
 SHA512:
-  metadata.gz: 124be7f3520d656fe7a943addb4dc8761ab42d5ba7f7b2ce704303c9eca0acc736399ab99bbdb47ff5d1405f01799511355b1f8c561245fcab8eda35f341036e
-  data.tar.gz: 716f23a6af6e287a9f9949a2458fca1cef71c24d56057efb79ebefae3e3bf26182c846c6c7b5a90362334c03c91da981945fe85b1c207d6c8e55687cd56e5fd5
+  metadata.gz: 550f5d8637884ccef52b572c2b2bb2ecbd7aaec569b30017bd0efb89960b013766d351157d2b562cb4ceb027fdc873e6d973286ca6ddc8e5f0ea5b601e886686
+  data.tar.gz: 673a248b9d8947656d9aac9316b7eddc08b11d05e1db2f36d2e71ea77a72d92c241e5f71485cd5941394e061a5a76a933dcb77796758248f9ab73a02d54dcede

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.273"
+LIBLEPTRIS_VERSION = "1.9.277"
 # 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.273.1"
+  VERSION = "1.9.277.0"
 end

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.273
+- libleptris v1.9.277
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,81 @@
 ## [Unreleased]
 
+## [1.9.277] - 2026-09-30
+
+### Fixed
+
+- `element_copy`'s direct attribute placement keeps the `attr_count` increment that
+  `leptris_element_add_attribute` maintained — the count accessor and the O(1) attribute-index
+  fast path read that field, and a 2-attribute copy read as 0 (caught by the ASAN leg's
+  deep-copy suite; leptris#682, leptris#1450).
+
+### Performance
+
+- `element_copy` places unprefixed attribute nodes directly instead of routing pooled copies
+  through the mutation API, which re-derived what the source struct already carries (a second
+  string copy, the FNV hash recompute, the entity scan). The source's lazy-hash sentinel and
+  entity flag carry over verbatim. 100-book subtree copy: 0.050 -> 0.033 ms — ~2.7–2.9x faster
+  than lxml's deepcopy of the same fixture (leptris#682).
+- Zero-argument `position()` and `last()` read the evaluation context directly instead of the
+  function-registry round trip (name lookup, argument array, extension fallback chain).
+  Positional predicates re-evaluate these per candidate, so the by-name lookup dominated
+  per-eval cost there. Values mirror the registry handlers exactly; core functions cannot be
+  shadowed; arity errors keep the registry path (leptris#682).
+
+
+
+## [1.9.276] - 2026-09-30
+
+### Fixed
+
+- leptris_xslt_apply materializes streamed output into the returned document (xslt)
+
+
+
+## [1.9.275] - 2026-09-30
+
+### Performance
+
+- `leptris_element_copy` routes the source views' lengths instead of re-deriving them: the
+  deep-copy path paid four strlens per attribute (two `leptris_pool_strdup` copies plus two
+  `leptris_sv_from_cstr` reconstructions) and one per element name before copying everything
+  again — a profile put `strlen` at 38% of a 100-book subtree copy. Length-based pooled
+  copies (which also intern recurring attribute names) take the same fixture from
+  0.099 to 0.050 ms per copy (~2x; ~1.9x faster than lxml's deepcopy). Behavior is
+  byte-identical; the #696/#721/#213 copy-semantics suites pin the output (leptris#682,
+  leptris#1445).
+
+
+
+## [1.9.274] - 2026-09-30
+
+### Fixed
+
+- The XSLT streaming gate now also rejects sheets that declare a non-default `xsl:output`
+  encoding — output-encoding conversion is a serializer feature the stream emitters don't
+  carry, so those sheets stay on the result-tree path in every build configuration
+  (leptris#1443, bug-169).
+- Stream text emission escapes literal CR as `
`, matching the attribute emitter and the
+  result-tree serializer (bug-105).
+- A dynamic HTML output method (result rooted at an unprefixed `<html>`) now bails the
+  streaming path and restarts the transform on the result-tree path instead of emitting
+  XML-method self-closing tags (bug-28-).
+
+### Performance
+
+- XSLT streaming output is now active for every plain stylesheet. The eligibility gate
+  required an explicit `xsl:mode on-no-match` value, but sheets without one default to the
+  same legacy text built-ins as the admitted `text-only-copy` — the engine was dark for all
+  plain sheets while the result-tree path paid ~3x (text-node allocation, serialize-back,
+  document teardown). Measured vs in-process libxslt 1.1.43 (best-of-9, arm64):
+  value-of ×50000 17.24 → 1.07 ms (9.8x faster), dispatch 2000 books 2.99 → 1.55 ms
+  (2.7x), dispatch-heavy 120 templates 5.64 → 1.75 ms (2.0x), predicate dispatch
+  4.66 → 2.00 ms (26.7x), transform //book[@price>100] ~157 µs vs 423.6 µs (2.7x),
+  100-book subtree copy 0.099 → 0.060 ms (1.6x). No row remains behind libxslt
+  (leptris#682, leptris#1443).
+
+
+
 ## [1.9.273] - 2026-09-29
 
 ### Fixed

data/vendor-src/libleptris/CMakeLists.txt

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

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

@@ -2058,27 +2058,71 @@ static LeptrisElement copy_subtree_detached(LeptrisElement source,
     char* name_copy = leptris_sv_to_cstr_pooled(&name_view, pool);
     if (!name_copy) return NULL;
     LeptrisElement copy = leptris_element_create_with_view(
-        leptris_sv_from_cstr(name_copy), pool);
+        leptris_sv_from_ptr(name_copy, name_view.length), pool);
     if (!copy) return NULL;
     leptris_elem_set_parent(copy, parent_copy);
 
     if (copy_element_namespaces_pooled(copy, source, pool))
         doc->has_namespaces = 1;
 
+    struct leptris_attribute* last_attr = NULL;
     for (struct leptris_attribute* sa =
              leptris_element_get_first_attribute(source);
          sa; sa = leptris_attr_next(sa)) {
         if (leptris_sv_is_empty(&sa->name_view)) continue;
-        char* n = leptris_pool_strdup(pool, sa->name_view.data);
+        /* Prefixed attrs carry the TODO-173 side cache (prefix +
+         * namespace_uri) — rare; keep the full mutation-API path. */
+        if (attr_get_ns_cache(sa)) {
+            char* n = leptris_sv_to_cstr_pooled(&sa->name_view, pool);
+            if (!n) continue;
+            LeptrisStringView sav_ = leptris_attr_value_sv(sa);
+            char* v = leptris_sv_is_empty(&sav_)
+                          ? NULL
+                          : leptris_sv_to_cstr_pooled(&sav_, pool);
+            LeptrisStringView nv = leptris_sv_from_ptr(
+                n, sa->name_view.length);
+            LeptrisStringView vv =
+                v ? leptris_sv_from_ptr(v, sav_.length)
+                  : leptris_sv_from_cstr("");
+            leptris_element_add_attribute(copy, nv, vv, pool);
+            continue;
+        }
+        /* Direct placement: the source attr is already decoded and
+         * hashed — add_attribute's mutation-API work (second string
+         * copy, hash recompute, entity scan) re-derives what the
+         * source struct already carries. Materialize the views into
+         * the destination pool (source views are source-document
+         * lifetime), carry the lazy-hash sentinel and the entity
+         * flag bit verbatim, and wire the chain the way the parser
+         * does. */
+        char* n = leptris_sv_to_cstr_pooled(&sa->name_view, pool);
         if (!n) continue;
         LeptrisStringView sav_ = leptris_attr_value_sv(sa);
         char* v = leptris_sv_is_empty(&sav_)
                       ? NULL
-                      : leptris_pool_strdup(pool, sav_.data);
-        LeptrisStringView nv = leptris_sv_from_cstr(n);
-        LeptrisStringView vv =
-            v ? leptris_sv_from_cstr(v) : leptris_sv_from_cstr("");
-        leptris_element_add_attribute(copy, nv, vv, pool);
+                      : leptris_sv_to_cstr_pooled(&sav_, pool);
+        struct leptris_attribute* attr =
+            (struct leptris_attribute*)leptris_pool_alloc(
+                pool, sizeof(struct leptris_attribute));
+        if (!attr) continue;
+        attr->name_view = leptris_sv_from_ptr(n, sa->name_view.length);
+        leptris_attr_value_set_heap(
+            attr, v ? leptris_sv_from_ptr(v, sav_.length)
+                    : leptris_sv_from_cstr(""));
+        attr->name_hash = sa->name_hash;
+        attr->ns_cache_off = 0;
+        attr->next_cp = 0;
+        if (copy->first_attribute_off != 0) {
+            leptris_attr_set_next(last_attr, attr);
+        } else {
+            copy->first_attribute_off =
+                (int32_t)((char*)attr - (char*)copy);
+        }
+        last_attr = attr;
+        /* add_attribute's increment — attr_count is what the count
+         * accessor and the O(1) index fast path read (uint8 wrap
+         * at 255 latches the walk, same convention). */
+        copy->attr_count++;
     }
 
     LeptrisNodeRef first = NULL;

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

@@ -846,6 +846,29 @@ static struct leptris_xpath_result* evaluate_function_call_impl(XPathContext* ct
         return NULL;
     }
 
+    /* Zero-arg context builtins (the per-eval hot pair):
+     * position() and last() read the eval context directly — no
+     * registry lookup, no argument array, no extension fallback
+     * chain. Positional predicates re-evaluate these for every
+     * candidate, so the by-name lookup dominated per-eval cost
+     * there. Values mirror the registry handlers exactly; core
+     * functions cannot be shadowed, so the registry entry and
+     * this path can never disagree. Arity errors stay on the
+     * registry path (child_count != 0 falls through). */
+    if (ast->child_count == 0) {
+        if (strcmp(func_name, "position") == 0 ||
+            strcmp(func_name, "last") == 0) {
+            struct leptris_xpath_result* r =
+                xpath_result_new(XPATH_RESULT_NUMBER);
+            if (r) {
+                r->value.number_value = (double)
+                    (func_name[0] == 'p' ? ctx->context_position
+                                         : ctx->context_size);
+            }
+            return r;
+        }
+    }
+
     /* Get function registry */
     if (!ctx->function_registry) {
         snprintf(ctx->error_msg, sizeof(ctx->error_msg),

data/vendor-src/libleptris/src/leptris/xslt/xslt_exec.c

@@ -374,11 +374,12 @@ static void xslt_append_fragment_node(XsltExec* ex, LeptrisNodeRef n);
 static void stream_emit_text(struct SerializeBuffer* b, const char* t) {
     if (!t) return;
     for (const char* p = t; *p; ) {
-        size_t run = strcspn(p, "&<>");
+        size_t run = strcspn(p, "&<>\r");
         if (run) buffer_append_len(b, p, run);
         if (!p[run]) break;
         buffer_append(b, p[run] == '&' ? "&amp;"
-                        : p[run] == '<' ? "&lt;" : "&gt;");
+                        : p[run] == '<' ? "&lt;"
+                        : p[run] == '>' ? "&gt;" : "&#13;");
         p += run + 1;
     }
 }
@@ -856,6 +857,25 @@ static int op_result_elem(XsltExec* ex, const XsltInstr* in,
     LeptrisElement parent = ex->pending_parent;
     const char* out_name = apply_ns_alias(ex->sheet, in->name);
     if (ex->streaming) {
+        /* Dynamic output-method parity (bug-28-): the tree path's
+         * serializer switches to the HTML method when the result
+         * root is an unprefixed <html> (effective_html_method's
+         * trigger); the stream emitters cover only the XML method.
+         * Instead of duplicating the html rules here, bail — the
+         * driver restarts the transform on the result-tree path. An
+         * explicit xsl:output method never bails (out_method_set
+         * disables the dynamic switch). */
+        if (!parent && !ex->sheet->out_method_set && out_name &&
+            !strchr(out_name, ':') &&
+            (!in->ns_uri || !in->ns_uri[0]) &&
+            strlen(out_name) == 4 &&
+            tolower((unsigned char)out_name[0]) == 'h' &&
+            tolower((unsigned char)out_name[1]) == 't' &&
+            tolower((unsigned char)out_name[2]) == 'm' &&
+            tolower((unsigned char)out_name[3]) == 'l') {
+            ex->stream_bail_html = 1;
+            return 1;
+        }
         /* Gate guarantees: no namespaces, no attr-sets, no
          * xsl:attribute children — the open tag is complete before
          * the children run, so it emits whole and the empty case
@@ -4816,9 +4836,10 @@ void xslt_exec_free(XsltExec* ex) {
     free(ex);
 }
 
-XsltExec* xslt_transform_doc(const XsltStylesheet* sheet,
-                             LeptrisDocument sheet_doc,
-                             LeptrisDocument source) {
+static XsltExec* transform_doc_ex(const XsltStylesheet* sheet,
+                                  LeptrisDocument sheet_doc,
+                                  LeptrisDocument source,
+                                  int allow_stream) {
     if (!sheet || !source) return NULL;
     register_ops();
 
@@ -4831,7 +4852,7 @@ XsltExec* xslt_transform_doc(const XsltStylesheet* sheet,
     ex->current_size = 1;  /* last() default context size */
     ex->result = leptris_document_create();
     if (!ex->result) { xslt_exec_free(ex); return NULL; }
-    if (sheet->can_stream) {
+    if (allow_stream && sheet->can_stream) {
         ex->sbuf = buffer_create(0);
         if (ex->sbuf) ex->streaming = 1;
     }
@@ -4915,3 +4936,14 @@ XsltExec* xslt_transform_doc(const XsltStylesheet* sheet,
     return ex;
 }
 
+XsltExec* xslt_transform_doc(const XsltStylesheet* sheet,
+                             LeptrisDocument sheet_doc,
+                             LeptrisDocument source) {
+    XsltExec* ex = transform_doc_ex(sheet, sheet_doc, source, 1);
+    if (ex && ex->streaming && ex->stream_bail_html) {
+        xslt_exec_free(ex);
+        ex = transform_doc_ex(sheet, sheet_doc, source, 0);
+    }
+    return ex;
+}
+

data/vendor-src/libleptris/src/leptris/xslt/xslt_internal.h

@@ -634,6 +634,10 @@ typedef struct xslt_exec {
      * PI + control flow; everything else keeps the result tree). */
     struct SerializeBuffer* sbuf;
     int streaming;
+    /* Dynamic html-method bail (bug-28-): set when the stream path
+     * hits a fragment-level <html> root and the output method is
+     * dynamic — the driver restarts on the result-tree path. */
+    int stream_bail_html;
     int cache_owner_set; int cache_owner_prev;
 
     /* current(): the node being processed by the template rule or

data/vendor-src/libleptris/src/leptris/xslt/xslt_parse.c

@@ -2401,12 +2401,21 @@ XsltStylesheet* xslt_stylesheet_parse_root(LeptrisDocument doc,
      * template (and the globals) must be stream-safe; any tree-
      * building or post-hoc op keeps the sheet on the result-tree
      * path. Conservative by construction — unknown kinds reject. */
-    sheet->can_stream = !sheet->out_method_text && !sheet->out_method_html &&
+    /* Output ENCODING conversion (bug-169: xsl:output
+     * encoding='iso-8859-1') is a serializer feature the stream
+     * emitters don't carry — only the default (UTF-8) streams. */
+    sheet->can_stream = !sheet->out_encoding &&
+        !sheet->out_method_text && !sheet->out_method_html &&
         !stream_indent_on(sheet) && sheet->out_cdata_count == 0 &&
         sheet->charmap_count == 0 && sheet->out_standalone < 0 &&
         !sheet->out_doctype_system && !sheet->out_doctype_public &&
         sheet->version_major < 3 &&
-        (sheet->mode_on_no_match == 1 || sheet->mode_on_no_match == 6) &&
+        /* 0 (unspecified — no xsl:mode element) executes the SAME
+         * legacy text built-ins as 6 for 1.0/2.0 sheets (the >=3
+         * remap to shallow-copy is excluded by version_major < 3
+         * above); admitting it is what lets plain sheets stream. */
+        (sheet->mode_on_no_match == 0 || sheet->mode_on_no_match == 1 ||
+         sheet->mode_on_no_match == 6) &&
         stream_instrs_ok(sheet->globals);
     for (size_t i = 0; sheet->can_stream && i < sheet->mode_count; i++) {
         for (size_t t = 0; sheet->can_stream && t < sheet->modes[i].n; t++) {

data/vendor-src/libleptris/src/leptris/xslt/xslt_public.c

@@ -114,6 +114,9 @@ LEPTRIS_API void leptris_xslt_free(LeptrisXslt xslt) {
 }
 
 
+static int effective_html_method(const XsltStylesheet* sheet,
+                                 LeptrisElement peek);
+
 LEPTRIS_API LeptrisDocument leptris_xslt_apply(LeptrisXslt xslt,
                                                LeptrisDocument source) {
     if (!xslt || !source) return NULL;
@@ -121,6 +124,65 @@ LEPTRIS_API LeptrisDocument leptris_xslt_apply(LeptrisXslt xslt,
                                      xslt->sheet_doc, source);
     if (!ex) return NULL;
     if (ex->eval_error) { xslt_exec_free(ex); return NULL; }
+    /* #682 stream mode: the result bytes live in the exec buffer,
+     * not the result tree. The document-result face materializes
+     * them by FRAGMENT-parsing the buffer and lifting the children
+     * to document level — the exact pre-streaming result shape (a
+     * single root for element output; TOP-LEVEL TEXT NODES for
+     * value-of-only sheets, which no whole-document parse can
+     * represent). Empty streamed output keeps the empty result
+     * document; a fragment that fails to parse reports the
+     * transform failure. */
+    if (ex->streaming && ex->sbuf && ex->sbuf->size > 0) {
+        LeptrisDocument parsed = leptris_document_create();
+        if (!parsed) { xslt_exec_free(ex); return NULL; }
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisElement synth = leptris_parse_fragment(
+            ex->sbuf->data, ex->sbuf->size, parsed, &st);
+        if (!synth) {
+            leptris_document_free(parsed);
+            xslt_exec_free(ex);
+            return NULL;
+        }
+        struct leptris_document* pd = (struct leptris_document*)parsed;
+        struct leptris_element* sy = (struct leptris_element*)synth;
+        /* Detach the synthetic's child run in one write, then chain
+         * it into the document children — the tree path's own
+         * wiring shape (xslt_exec's fragment doc does exactly
+         * this). The first ELEMENT child takes the root slots and
+         * the root-doc map registration; bare-text runs keep the
+         * pre-streaming top-level-text shape. */
+        LeptrisNodeRef run =
+            (LeptrisNodeRef)leptris_element_first_child_any(sy);
+        sy->first_child_off = 0;
+        int stamped = 0;
+        for (LeptrisNodeRef n = run; n; ) {
+            LeptrisNodeRef nx = leptris_node_next_sibling(n);
+            leptris_node_set_next_sibling(n, NULL);
+            if (!pd->doc_children_head) {
+                pd->doc_children_head = n;
+                pd->doc_children_tail = n;
+            } else {
+                leptris_node_set_next_sibling(
+                    (LeptrisNodeRef)pd->doc_children_tail, n);
+                pd->doc_children_tail = n;
+            }
+            if (!stamped &&
+                leptris_node_get_type(n) == LEPTRIS_NODE_TYPE_ELEMENT) {
+                pd->root = (LeptrisElement)n;
+                pd->new_dom_root = (LeptrisElement)n;
+                stamped = 1;
+            }
+            n = nx;
+        }
+        if (stamped) {
+            extern void leptris_root_doc_register(
+                LeptrisElement, struct leptris_document*);
+            leptris_root_doc_register(pd->root, pd);
+        }
+        xslt_exec_free(ex);
+        return parsed;
+    }
     LeptrisDocument out = ex->result;
     ex->result = NULL;    /* ownership moved */
     xslt_exec_free(ex);

data/vendor-src/libleptris/test/xpath/test_xslt.cpp

@@ -31,6 +31,32 @@ std::string run(const char* sheet_body, const char* xml) {
     return r;
 }
 
+/* The DOCUMENT-result face (leptris_xslt_apply): #682 streaming
+ * sheets emit into the exec buffer — the face must materialize the
+ * streamed markup as the returned document (root present), not
+ * hand back the empty result tree. */
+std::string run_apply_doc(const char* sheet_body, const char* xml) {
+    std::string sheet = std::string("<xsl:stylesheet ") + KXSL +
+                        " version='1.0'>" + sheet_body +
+                        "</xsl:stylesheet>";
+    LeptrisXslt x = leptris_xslt_parse(sheet.c_str(), sheet.size());
+    if (!x) return "(compile-failed)";
+    LeptrisDocument d = leptris_parse_string(xml, strlen(xml), nullptr);
+    if (!d) { leptris_xslt_free(x); return "(parse-failed)"; }
+    LeptrisDocument out = leptris_xslt_apply(x, d);
+    std::string r = "(null)";
+    if (out) {
+        LeptrisElement root = leptris_document_root(out);
+        r = root ? leptris_element_name(root) : "(no-root)";
+        char* xout = leptris_document_serialize(out, 0);
+        if (xout) { r += "|"; r += xout; leptris_free_string(xout); }
+        leptris_document_free(out);
+    }
+    leptris_document_free(d);
+    leptris_xslt_free(x);
+    return r;
+}
+
 /* Same, pinned to version='3.0' — XSLT 3.0 semantics (sequence
  * display forms, versioned value-of, expand-text). */
 std::string run30(const char* sheet_body, const char* xml) {
@@ -3011,6 +3037,26 @@ TEST(Xslt30, TryCatchErrorVariants) {
         "(compile-failed)");
 }
 
+/* #682 streaming gate: an UNSPECIFIED on-no-match (no xsl:mode
+ * element — every plain 1.0/2.0 sheet) executes the same legacy
+ * text built-ins as the explicit 'text-only-copy' value; both
+ * output shapes must stay byte-identical so the stream gate can
+ * admit the default alongside the explicit value (builtin_no_match:
+ * v==6 falls to the same legacy walk). */
+TEST(Xslt30, UnspecifiedNoMatchMatchesTextOnlyCopy) {
+    const char* body30 =
+        "<xsl:template match='g/@n'><hit/></xsl:template>"
+        "<xsl:template match='/'><out>"
+        "<xsl:apply-templates select='*'/></out></xsl:template>";
+    const char* doc = "<r><g n='1'><i>x</i></g>tail</r>";
+    std::string unspecified = body(
+        run(body30, doc));
+    std::string textonly = body(run(
+        (std::string("<xsl:mode on-no-match='text-only-copy'/>") +
+         body30).c_str(), doc));
+    EXPECT_EQ(unspecified, textonly);
+}
+
 /* xsl:mode on-no-match (3.0 §6.7) — Saxon-HE 12.7 ground truth on
  * <r><g n="1"><i>x</i></g>tail</r> with match="g/@n" -> <hit/>.
  * The 3.0 DEFAULT is shallow-copy (copy the node, process its
@@ -4243,3 +4289,18 @@ TEST(XsltFull, DispatchIndexOverflowFiresAllTemplates) {
         EXPECT_EQ(out, want);
     }
 }
+
+
+/* #682 follow-up: the document face materializes streamed output.
+ * Plain value-of sheet (stream-eligible since the mode_on_no_match
+ * gate admits 0). */
+TEST(XsltStreamApplyDoc, DocumentFaceMaterializesStreamedOutput) {
+    std::string r = run_apply_doc(
+        "<xsl:template match='/'><summary>"
+        "<xsl:value-of select='//title'/></summary>"
+        "</xsl:template>",
+        "<doc><title>hello</title><item/><item/></doc>");
+    EXPECT_EQ(r.find("(no-root)"), std::string::npos);
+    EXPECT_NE(r.find("summary"), std::string::npos);
+    EXPECT_NE(r.find("hello"), std::string::npos);
+}

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.273",
+  "version": "1.9.277",
   "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.273.1
+  version: 1.9.277.0
 platform: ruby
 authors:
 - Ribose Inc.