leptris 1.9.321.0-aarch64-linux → 1.9.323.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db9055121618343dff8b5e698e7c92d47dbd434db73fe6d8339dc46a0be73c82
-  data.tar.gz: 3e7cf86ffa532fff238034f21f55dbc7117a85398fd1aed4bf3ade5d0c7c3b4e
+  metadata.gz: 2952b2796c8abade02c179d5fc354286188f58cb883f6e3c6589af9bf9636730
+  data.tar.gz: 33f7096e37bf17398b841aa580c37b9f2d92c9bfac61e3a5e12690681714a741
 SHA512:
-  metadata.gz: 3a625fa0c0ef2ac0e64244b09872d64e6f2f6c9a0610c8b65a1c931b69006755e7ce6afe380a0a0a4c8980916e2aeb57dfebbf9b0fde1baf7a5d298dfb866c36
-  data.tar.gz: 4607ae9d6d1952a36f2d9b100417e97c77bca875aeee0dafa5736168d3b6a2966f6ead5a59d1384d8f8ec3adebd542ff05e41ce2fc632767fa466fcf539538cb
+  metadata.gz: c9d05126e8bb3d6c3e686fcfb1867603db31b3b90ee634d52ff6543d02f03df92bc235c5bd0663c003e8880e650042be164c15dc4964ab832963f52a03a7b060
+  data.tar.gz: 4bc862cce974f3e2dc8d09e8e2b5d03aa7751344f154c6f42d8bfe34d8d31759f7376ac0f6bce829545fa2a5b100e553f8cdf7a7edc377b4d3c06edb49bc9481

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## [1.9.323.0] - 2026-10-08
+
+### Fixed — engine sync (libleptris 1.9.323)
+
+- **Inline anonymous complexType/simpleType capture (#1592,
+  engine PR #1596)**: elements carrying an inline anonymous type —
+  the most common XSD spelling — previously got no content model
+  (instance validation silently skipped their content check;
+  content_valid? answered -1). Inline types capture under a
+  synthesized element:NAME slot now; particle text types through
+  the slot too. Pinned: content-model enforcement with enumerated
+  errors, content_valid? answering, anonymous simpleType
+  patterns binding.
+
+## [1.9.322.0] - 2026-10-08
+
+### Engine sync (libleptris 1.9.322)
+
+- `leptris validate --xsd FILE` rides the CLI's validate command
+  (compile error detail, every accumulated instance error,
+  non-zero exit) — CLI-only, no binding surface; audit 381/380
+  unchanged. The inline-anonymous complexType capture fix
+  (leptris#1592, engine PR #1596) merged after this tag and ships
+  with the engine's next release — the binding pin follows there.
+
 ## [1.9.321.0] - 2026-10-08
 
 ### Added — engine sync (libleptris 1.9.321)

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.321"
+LIBLEPTRIS_VERSION = "1.9.323"
 # 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.321.0"
+  VERSION = "1.9.323.0"
 end

data/lib/leptris/xml/document.rb

@@ -533,6 +533,11 @@ class Leptris::XML::Document
       Leptris::XML::Serialization::DOCUMENT_SERIALIZE_INTO, c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
+
+  # Nokogiri parity (leptris#1595): to_s serializes the document.
+  def to_s
+    to_xml
+  end
   alias_method :to_s, :to_xml
   alias_method :serialize, :to_xml
 

data/lib/leptris/xml/element.rb

@@ -943,6 +943,14 @@ class Leptris::XML::Element < Leptris::XML::Node
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
 
+  # Nokogiri parity (leptris#1595): to_s serializes the node —
+  # the default Object#to_s object dump leaked into migrated
+  # consumers (coradoc math stems). Serialization options ride
+  # to_xml; to_s is the no-options convenience form.
+  def to_s
+    to_xml
+  end
+
   # HTML5 serialization of this element subtree (#309 — see
   # Document#to_html for the semantics).
   def to_html

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

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,35 @@
 ## [Unreleased]
 
+## [1.9.323] - 2026-10-08
+
+### Fixed
+
+- **XSD: inline anonymous complexType/simpleType capture
+  (#1592, PR #1596).** Elements carrying an inline anonymous type —
+  arguably the most common XSD spelling — got no content model:
+  instance validation silently skipped their content check and
+  `leptris_xsd_content_valid` answered −1. Inline types now capture
+  under a synthesized `element:NAME` slot (collision-free — `:`
+  cannot appear in xs: NCName type names): top-level elements and
+  every particle fall back to the inline capture when the type
+  attribute is absent, and local simpleType particles type their
+  text through the slot.
+
+
+
+## [1.9.322] - 2026-10-08
+
+### Added
+
+- **`leptris validate --xsd FILE` (#1075, PR #1593).** The compiled
+  XSD surface rides the same validate command as `--dtd`/`--rng`/
+  `--schematron`: compile failures report the schema's own error
+  detail (compile returns error-carrying handles — the status keys
+  the failure); invalid documents print every accumulated error and
+  exit non-zero.
+
+
+
 ## [1.9.321] - 2026-10-08
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

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

data/vendor-src/libleptris/cli/commands/validate.c

@@ -156,6 +156,7 @@ static int run_schematron(const char* path, const char* phase,
 
 static cli_result_t validate_execute(int argc, char** argv) {
     const char* rng_path = NULL;
+    const char* xsd_path = NULL;
     const char* sch_path = NULL;
     const char* dtd_path = NULL;
     const char* phase = NULL;
@@ -164,6 +165,8 @@ static cli_result_t validate_execute(int argc, char** argv) {
     for (int i = 1; i < argc; i++) {
         if (strcmp(argv[i], "--rng") == 0 && i + 1 < argc) {
             rng_path = argv[++i];
+        } else if (strcmp(argv[i], "--xsd") == 0 && i + 1 < argc) {
+            xsd_path = argv[++i];
         } else if ((strcmp(argv[i], "--schematron") == 0 ||
                     strcmp(argv[i], "-s") == 0) &&
                    i + 1 < argc) {
@@ -184,6 +187,7 @@ static cli_result_t validate_execute(int argc, char** argv) {
             printf("Options:\n");
             printf("  --dtd FILE          External DTD\n");
             printf("  --rng FILE          RELAX NG schema\n");
+            printf("  --xsd FILE          W3C XML Schema (XSD)\n");
             printf("  --schematron FILE   ISO Schematron schema\n");
             printf("  --phase ID          Schematron phase to");
             printf(" select\n");
@@ -205,8 +209,8 @@ static cli_result_t validate_execute(int argc, char** argv) {
         cli_error("validate requires an XML document");
         return CLI_ERROR_ARGS;
     }
-    if (!rng_path && !sch_path && !dtd_path) {
-        cli_error("validate needs --dtd and/or --rng and/or --schematron");
+    if (!rng_path && !sch_path && !dtd_path && !xsd_path) {
+        cli_error("validate needs --dtd/--rng/--schematron/--xsd");
         return CLI_ERROR_ARGS;
     }
     LeptrisDocument doc = read_doc(xml_path);
@@ -261,6 +265,43 @@ static cli_result_t validate_execute(int argc, char** argv) {
         }
         leptris_rng_free(rng);
     }
+    if (xsd_path) {
+        size_t xsd_len = 0;
+        char* xsd_content = read_file(xsd_path, &xsd_len);
+        if (!xsd_content) {
+            cli_error("cannot read XSD: %s", xsd_path);
+            leptris_document_free(doc);
+            return CLI_ERROR_IO;
+        }
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisXsdSchema xsd =
+            leptris_xsd_compile(xsd_content, xsd_len, &st);
+        free(xsd_content);
+        /* compile returns an error-carrying handle on failure — the
+         * status, not the pointer, says whether it succeeded. */
+        if (st != LEPTRIS_OK) {
+            const char* detail =
+                xsd ? leptris_xsd_error(xsd)
+                    : leptris_status_string(st);
+            cli_error("XSD compile failed: %s",
+                      detail ? detail : leptris_status_string(st));
+            if (xsd) leptris_xsd_free(xsd);
+            leptris_document_free(doc);
+            return CLI_ERROR_IO;
+        }
+        if (leptris_xsd_validate(xsd, doc)) {
+            printf("xsd: valid\n");
+        } else {
+            printf("xsd: invalid\n");
+            size_t n = leptris_xsd_error_count(xsd);
+            for (size_t i = 0; i < n; i++) {
+                const char* e = leptris_xsd_error_at(xsd, i);
+                if (e) printf("  %s\n", e);
+            }
+            invalid = 1;
+        }
+        leptris_xsd_free(xsd);
+    }
     if (sch_path) {
         cli_result_t r = run_schematron(
             sch_path, phase, want_svrl, doc, &invalid);
@@ -276,7 +317,8 @@ static cli_result_t validate_execute(int argc, char** argv) {
 
 static cli_command_t validate_command = {
     .name = "validate",
-    .description = "Validate XML against RELAX NG / Schematron",
+    .description =
+        "Validate XML against RELAX NG / Schematron / XSD",
     .execute = validate_execute,
     .print_help = NULL
 };

data/vendor-src/libleptris/src/leptris/xsd/compile.c

@@ -4,6 +4,7 @@
  * grow the model (datatypes, facets, content models, identity
  * constraints) — this slice's contract is the API shape, the
  * xs:schema identity check, and the declaration enumeration. */
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -41,6 +42,20 @@ struct leptris_xsd_schema {
 
 static char* xsd_strdup(const char* s);
 
+/* #1592: capture an INLINE anonymous xs:complexType / xs:simpleType
+ * under a synthesized name ("element:NAME" — ':' cannot appear in
+ * xs: NCName type names, so the slot is collision-free). Returns 1
+ * when a capture happened. Forward decls below; definitions later
+ * in this file. */
+static int xsd_capture_inline(struct leptris_xsd_schema* s,
+                              LeptrisElement elem, const char* synth);
+static XsdCm* xsd_cm_new(XsdCmKind kind);
+static void xsd_cm_occurrence(XsdCm* cm, LeptrisElement e);
+static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
+                           LeptrisElement group, XsdCm** tail_out);
+static XsdSimple* xsd_capture_simple(LeptrisElement st);
+
+
 static XsdCm* xsd_cm_new(XsdCmKind kind) {
     XsdCm* cm = (XsdCm*)calloc(1, sizeof(*cm));
     if (!cm) return NULL;
@@ -73,7 +88,45 @@ static void xsd_cm_occurrence(XsdCm* cm, LeptrisElement e) {
 /* Recursive model build over sequence | choice | all | element |
  * any children. Returns the child list head; *tail_out receives
  * the list tail for sibling chaining. */
-static XsdCm* xsd_cm_parse(LeptrisElement group, XsdCm** tail_out) {
+/* #1592: capture an INLINE anonymous xs:complexType / xs:simpleType
+ * under a synthesized name ("element:NAME" — ':' cannot appear in
+ * xs: NCName type names, so the slot is collision-free). Returns 1
+ * when a capture happened. */
+static int xsd_capture_inline(struct leptris_xsd_schema* s,
+                              LeptrisElement elem, const char* synth) {
+    for (LeptrisNodeRef n =
+             leptris_node_first_child(leptris_element_as_node(elem));
+         n; n = leptris_node_next_sibling(n)) {
+        if (leptris_node_get_type(n) != LEPTRIS_NODE_TYPE_ELEMENT)
+            continue;
+        LeptrisElement e = (LeptrisElement)n;
+        const char* local = NULL, *prefix = NULL, *uri = NULL;
+        leptris_element_expanded_name(e, &local, &prefix, &uri);
+        if (!local || !uri || strcmp(uri, XSD_NS) != 0) continue;
+        if (strcmp(local, "complexType") == 0) {
+            XsdCm* root = xsd_cm_new(XSD_CM_SEQ);
+            if (!root) return 0;
+            root->name = xsd_strdup(synth);
+            root->first_child = xsd_cm_parse(s, e, NULL);
+            root->next = s->complex_types;
+            s->complex_types = root;
+            return 1;
+        }
+        if (strcmp(local, "simpleType") == 0) {
+            XsdSimple* captured = xsd_capture_simple(e);
+            if (!captured) return 0;
+            free(captured->name);
+            captured->name = xsd_strdup(synth);
+            captured->next = s->simple_types;
+            s->simple_types = captured;
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static XsdCm* xsd_cm_parse(struct leptris_xsd_schema* s,
+                           LeptrisElement group, XsdCm** tail_out) {
     XsdCm* head = NULL;
     XsdCm* tail = NULL;
     for (LeptrisNodeRef n =
@@ -92,7 +145,7 @@ static XsdCm* xsd_cm_parse(LeptrisElement group, XsdCm** tail_out) {
             cm = xsd_cm_new(strcmp(local, "sequence") == 0 ? XSD_CM_SEQ
                             : strcmp(local, "choice") == 0 ? XSD_CM_CHOICE
                                                            : XSD_CM_ALL);
-            if (cm) cm->first_child = xsd_cm_parse(e, NULL);
+            if (cm) cm->first_child = xsd_cm_parse(s, e, NULL);
         } else if (strcmp(local, "element") == 0) {
             cm = xsd_cm_new(XSD_CM_ELEMENT);
             if (cm) {
@@ -100,8 +153,17 @@ static XsdCm* xsd_cm_parse(LeptrisElement group, XsdCm** tail_out) {
                     leptris_element_attribute(e, "name");
                 if (!nm) nm = leptris_element_attribute(e, "ref");
                 cm->name = xsd_strdup(nm);
-                cm->type = xsd_strdup(
-                    leptris_element_attribute(e, "type"));
+                const char* pty =
+                    leptris_element_attribute(e, "type");
+                if (pty) {
+                    cm->type = xsd_strdup(pty);
+                } else if (s && nm) {
+                    /* #1592: inline anonymous type on the particle */
+                    char synth[512];
+                    snprintf(synth, sizeof(synth), "element:%s", nm);
+                    if (xsd_capture_inline(s, e, synth))
+                        cm->type = xsd_strdup(synth);
+                }
             }
         } else if (strcmp(local, "any") == 0) {
             cm = xsd_cm_new(XSD_CM_ANY);
@@ -140,7 +202,9 @@ static char* xsd_strdup(const char* s) {
 /* Capture one xs:simpleType's restriction model (slice 2). */
 static XsdSimple* xsd_capture_simple(LeptrisElement st) {
     const char* name = leptris_element_attribute(st, "name");
-    if (!name) return NULL; /* anonymous types ride their element */
+    /* Anonymous types ride their element — allowed: the caller
+     * renames the captured entry into its synthesized slot
+     * (#1592). */
 
     XsdSimple* simple = (XsdSimple*)calloc(1, sizeof(*simple));
     if (!simple) return NULL;
@@ -323,6 +387,21 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
                     d->next = s->elements;
                     s->elements = d;
                 }
+            } else if (nm) {
+                /* #1592: inline anonymous type — capture under the
+                 * synthesized slot and point the declaration at it. */
+                char synth[512];
+                snprintf(synth, sizeof(synth), "element:%s", nm);
+                if (xsd_capture_inline(s, (LeptrisElement)n, synth)) {
+                    XsdElementDecl* d =
+                        (XsdElementDecl*)calloc(1, sizeof(*d));
+                    if (d) {
+                        d->name = xsd_strdup(nm);
+                        d->type = xsd_strdup(synth);
+                        d->next = s->elements;
+                        s->elements = d;
+                    }
+                }
             }
         } else if (strcmp(local, "complexType") == 0 && uri &&
                    !strcmp(uri, XSD_NS)) {
@@ -334,7 +413,7 @@ LEPTRIS_API LeptrisXsdSchema leptris_xsd_compile(const char* xsd_text,
                 if (root) {
                     root->name = xsd_strdup(nm);
                     root->first_child =
-                        xsd_cm_parse((LeptrisElement)n, NULL);
+                        xsd_cm_parse(s, (LeptrisElement)n, NULL);
                     root->next = s->complex_types;
                     s->complex_types = root;
                 }

data/vendor-src/libleptris/test/cli/test_cli.cpp

@@ -552,3 +552,37 @@ TEST(CliValidate, MissingDtdIsIoError) {
 }
 
 #endif  /* !_WIN32 */
+
+// ---- validate --xsd (#1075 slice 5) ---------------------------------
+// The compiled XSD surface rides the same validate command as
+// dtd/rng/schematron. Windows runners: same harness limitation as
+// CliDiff (path + tmp semantics).
+#ifndef _WIN32
+TEST(CliValidateXsd, ValidDocumentExitsZero) {
+    write_file("leptris_cli_xsd.tmp",
+               "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+               "<xs:element name=\"r\" type=\"xs:integer\"/></xs:schema>");
+    auto r = run_cli({"validate", "--xsd", "leptris_cli_xsd.tmp",
+                      "-"}, "<r>7</r>");
+    EXPECT_EQ(r.exit_code, 0) << "stderr: " << r.err;
+    EXPECT_NE(r.out.find("xsd: valid"), std::string::npos);
+}
+
+TEST(CliValidateXsd, InvalidDocumentReportsAndExitsNonzero) {
+    write_file("leptris_cli_xsd2.tmp",
+               "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+               "<xs:element name=\"r\" type=\"xs:integer\"/></xs:schema>");
+    auto r = run_cli({"validate", "--xsd", "leptris_cli_xsd2.tmp",
+                      "-"}, "<r>nope</r>");
+    EXPECT_NE(r.exit_code, 0);
+    EXPECT_NE(r.out.find("xsd: invalid"), std::string::npos);
+}
+
+TEST(CliValidateXsd, CompileFailureIsReported) {
+    write_file("leptris_cli_xsd3.tmp", "<not-a-schema/>");
+    auto r = run_cli({"validate", "--xsd", "leptris_cli_xsd3.tmp",
+                      "-"}, "<r>7</r>");
+    EXPECT_NE(r.exit_code, 0);
+    EXPECT_NE(r.err.find("XSD compile failed"), std::string::npos);
+}
+#endif

data/vendor-src/libleptris/test/xsd/test_xsd_compile.cpp

@@ -517,3 +517,91 @@ TEST(XsdValidate, NullTolerant) {
 }
 
 }  // namespace
+
+// ---- #1592: inline anonymous types ---------------------------------
+namespace {
+
+const char* k_anon_schema =
+    "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+    "<xs:element name=\"book\">"
+    "<xs:complexType>"
+    "<xs:sequence>"
+    "<xs:element name=\"title\" type=\"xs:token\"/>"
+    "<xs:element name=\"author\" type=\"xs:token\"/>"
+    "</xs:sequence>"
+    "</xs:complexType>"
+    "</xs:element>"
+    "</xs:schema>";
+
+TEST(XsdContent, AnonymousInlineComplexTypeCaptured) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile(k_anon_schema, strlen(k_anon_schema), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    /* the issue's exact symptom: content_valid answered -1 */
+    const char* good[] = {"title", "author"};
+    EXPECT_EQ(leptris_xsd_content_valid(s, "book", good, NULL, 2), 1);
+    const char* bad[] = {"author", "author", "isbn"};
+    EXPECT_EQ(leptris_xsd_content_valid(s, "book", bad, NULL, 3), 0);
+    const char* miss[] = {"author"};
+    EXPECT_EQ(leptris_xsd_content_valid(s, "book", miss, NULL, 1), 0);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdValidate, AnonymousInlineValidatesEndToEnd) {
+    LeptrisStatus st = LEPTRIS_OK;
+    LeptrisXsdSchema s =
+        leptris_xsd_compile(k_anon_schema, strlen(k_anon_schema), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* good_x = "<book><title>t</title><author>a</author></book>";
+    LeptrisDocument good =
+        leptris_parse_string(good_x, strlen(good_x), &st);
+    ASSERT_NE(good, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, good), 1);
+    leptris_document_free(good);
+    /* the issue's instance: missing title, out-of-model isbn */
+    const char* bad_x =
+        "<book><author/><author/><isbn>9</isbn></book>";
+    LeptrisDocument bad = leptris_parse_string(bad_x, strlen(bad_x), &st);
+    ASSERT_NE(bad, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, bad), 0);
+    EXPECT_GE(leptris_xsd_error_count(s), 1u);
+    leptris_document_free(bad);
+    leptris_xsd_free(s);
+}
+
+TEST(XsdDatatypes, AnonymousInlineSimpleTypeOnParticle) {
+    LeptrisStatus st = LEPTRIS_OK;
+    const char* xsd =
+        "<xs:schema xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">"
+        "<xs:complexType name=\"t\">"
+        "<xs:sequence>"
+        "<xs:element name=\"score\">"
+        "<xs:simpleType>"
+        "<xs:restriction base=\"xs:integer\">"
+        "<xs:minInclusive value=\"1\"/>"
+        "</xs:restriction>"
+        "</xs:simpleType>"
+        "</xs:element>"
+        "</xs:sequence></xs:complexType>"
+        "<xs:element name=\"game\" type=\"t\"/>"
+        "</xs:schema>";
+    LeptrisXsdSchema s = leptris_xsd_compile(xsd, strlen(xsd), &st);
+    ASSERT_NE(s, (LeptrisXsdSchema)0);
+    const char* good_x = "<game><score>9</score></game>";
+    LeptrisDocument good = leptris_parse_string(good_x, strlen(good_x), &st);
+    ASSERT_NE(good, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, good), 1);
+    leptris_document_free(good);
+    const char* bad_x = "<game><score>0</score></game>";
+    LeptrisDocument bad = leptris_parse_string(bad_x, strlen(bad_x), &st);
+    ASSERT_NE(bad, nullptr);
+    EXPECT_EQ(leptris_xsd_validate(s, bad), 0);
+    leptris_document_free(bad);
+    /* the synthesized slot resolves directly too */
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "element:score", "9"), 1);
+    EXPECT_EQ(leptris_xsd_simple_valid(s, "element:score", "0"), 0);
+    leptris_xsd_free(s);
+}
+
+}  // namespace

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.321",
+  "version": "1.9.323",
   "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.321.0
+  version: 1.9.323.0
 platform: aarch64-linux
 authors:
 - Ribose Inc.