leptris 1.9.197.2-arm-linux

data/lib/leptris/xml/xpath.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+# Compiled XPath expression: parse once, evaluate many times against
+# any document (libleptris v1.6.0). The C handle is released by GC.
+#
+#     expr = Leptris::XML::XPath.compile("//item[@qty > 3]")
+#     expr.eval(doc_a).length
+#     expr.eval(doc_b, "p" => "urn:p").length
+#
+class Leptris::XML::XPath
+  class CompiledHandle < ::FFI::AutoPointer
+    def self.release(ptr)
+      Leptris::XML::FFI.leptris_xpath_compiled_free(ptr)
+    end
+  end
+
+  attr_reader :expression
+
+  # +version+ (#183, mirroring leptris-py#105): nil compiles the
+  # full-grammar expression (the default); :xpath10 / "1.0" pins
+  # the strict XPath 1.0 surface. Validated at the boundary.
+  def self.compile(expression, version: nil)
+    raw = Leptris::XML::FFI.leptris_xpath_compile(expression.to_s)
+    if raw.null?
+      raise Leptris::XML::XPathError,
+        "invalid expression: #{Leptris::XML::FFI.leptris_last_error}"
+    end
+    version_code =
+      Leptris::XML::Searchable.xpath_version_code(version) if version
+    new(expression.to_s, CompiledHandle.new(raw), version_code)
+  end
+
+  # Raw-pointer evaluation for Searchable's compiled cache
+  # (TODO.perf/15): the same entry the string path uses, against
+  # the compiled handle — no per-call parse/cache lookup.
+  def eval_ptrs(doc_ptr, context_ptr)
+    Leptris::XML::FFI.leptris_xpath_compiled_eval(
+      @handle, doc_ptr, context_ptr)
+  end
+
+  # Namespace-bound evaluation against the compiled handle
+  # (TODO.perf/29): the handle is ns-independent — compile once,
+  # bind per call through the cached ns set.
+  def eval_ns_ptrs(doc_ptr, context_ptr, ns_set_ptr)
+    Leptris::XML::FFI.leptris_xpath_compiled_eval_ns(
+      @handle, doc_ptr, context_ptr, ns_set_ptr)
+  end
+
+  def initialize(expression, handle, version_code = nil)
+    @expression = expression
+    @handle = handle
+    @version_code = version_code
+  end
+
+  # Evaluates against +doc_or_element+. An optional trailing hash of
+  # namespace bindings ("prefix" => uri) routes the evaluation through
+  # the namespace-bound path, matching Searchable#xpath semantics.
+  # A compiled version pin routes through the engine's versioned
+  # entry instead of the compiled handle — there is no compiled
+  # versioned lane yet (engine gap), so the strict-1.0 surface is
+  # enforced per evaluation over the stored expression.
+  def eval(doc_or_element, ns = nil)
+    context = Leptris::XML::EvaluationContext.of(doc_or_element)
+    document = context.document
+    result_ptr =
+      if @version_code
+        raise ArgumentError,
+          "version: cannot be combined with namespace bindings "           "(the versioned engine entry takes no ns set yet)" if ns && !ns.empty?
+        Leptris::XML::FFI.leptris_xpath_eval_versioned(
+          document.c_ptr, context.context_node_ptr,
+          @expression, @version_code, nil)
+      elsif ns && !ns.empty?
+        Leptris::XML::FFI.with_ns_set(ns) do |set|
+          Leptris::XML::FFI.leptris_xpath_compiled_eval_ns(
+            @handle, document.c_ptr, context.context_node_ptr, set)
+        end
+      else
+        Leptris::XML::FFI.leptris_xpath_compiled_eval(
+          @handle, document.c_ptr, context.context_node_ptr)
+      end
+    if result_ptr.null?
+      raise Leptris::XML::XPathError,
+        Leptris::XML::FFI.leptris_last_error.to_s
+    end
+    Leptris::XML::Searchable.wrap_xpath_result(document, result_ptr)
+  end
+end

data/lib/leptris/xml/xquery.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+# Compiled XQuery 1.0 query (libleptris 1.9.64+): parse once,
+# evaluate many times against any document. The engine layer
+# orchestrates the XPath engine — the prolog (declare variable /
+# namespace / function local:*) binds into the evaluation context,
+# FLWOR clauses run as a tuple stream, and results reuse the XPath
+# result handle.
+#
+#     query = Leptris::XML::XQuery.parse(<<~XQ)
+#       for $i in //item
+#       where $i/@qty > 3
+#       order by $i/@qty descending
+#       return <big>{$i/name/text()}</big>
+#     XQ
+#     query.eval(doc)   # => Leptris::XML::NodeSet
+#
+class Leptris::XML::XQuery
+  class Handle < ::FFI::AutoPointer
+    def self.release(ptr)
+      Leptris::XML::FFI.leptris_xquery_free(ptr)
+    end
+  end
+
+  def self.parse(query)
+    query = query.to_s
+    raw = Leptris::XML::FFI.leptris_xquery_parse(query, query.bytesize)
+    if raw.null?
+      raise Leptris::XML::XPathError,
+        "query parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+    end
+    new(query, Handle.new(raw))
+  end
+
+  attr_reader :query
+
+  def initialize(query, handle)
+    @query = query
+    @handle = handle
+  end
+
+  # Evaluates against +doc_or_element+. Plain-expression bodies keep
+  # their XPath result type (NodeSet / true/false / Float / String);
+  # FLWOR results arrive as the sequence channel — read them through
+  # an aggregate until the engine materializes readable sequence
+  # items (same caveat as the XPath for-return subset).
+  # +params+ binds external variables (libleptris 1.9.133): each
+  # value is an XPath expression evaluated in an empty context
+  # (QT3 <param select> semantics) — {"x" => "21 * 2"} binds
+  # `declare variable $x external`. A binding overrides the
+  # declaration's default initializer; an external with neither
+  # fails evaluation. An empty params hash takes the same lane —
+  # the engine decides between default initializer and failure.
+  def eval(doc_or_element, params = nil)
+    context = Leptris::XML::EvaluationContext.of(doc_or_element)
+    result_ptr =
+      if params
+        names, name_anchors = Leptris::XML::CStringArray.to_c(
+          params.keys.map(&:to_s))
+        selects, select_anchors = Leptris::XML::CStringArray.to_c(
+          params.values.map(&:to_s))
+        Leptris::XML::FFI.leptris_xquery_eval_params(
+          @handle, context.document.c_ptr, context.context_node_ptr,
+          names, selects, params.size)
+      else
+        Leptris::XML::FFI.leptris_xquery_eval(
+          @handle, context.document.c_ptr, context.context_node_ptr)
+      end
+    if result_ptr.null?
+      raise Leptris::XML::XPathError,
+        Leptris::XML::FFI.leptris_last_error.to_s
+    end
+    Leptris::XML::Searchable.wrap_xpath_result(context.document, result_ptr)
+  end
+end

data/lib/leptris/xml/xslt.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Leptris::XML::XSLT
+  module_function
+
+  def parse(stylesheet_xml)
+    Stylesheet.parse(stylesheet_xml)
+  end
+
+  def parse_file(path)
+    Stylesheet.parse_file(path)
+  end
+
+  # A compiled XSLT 1.0 stylesheet (libleptris 1.9.1): the stylesheet
+  # parses ONCE into an immutable instruction forest — patterns to
+  # XPath ASTs, selects through the compiled-XPath path — then applies
+  # to any number of documents with no re-parsing.
+  #
+  #     style = Leptris::XML::XSLT.parse(<<~XSL)
+  #       <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+  #         <xsl:template match="/"><out><xsl:value-of select="count(//item)"/></out></xsl:template>
+  #       </xsl:stylesheet>
+  #     XSL
+  #     style.apply_to(doc)      # => result Document (queryable tree)
+  #     style.serialize(doc)     # => String (fragments and top-level
+  #                              #    text nodes preserved)
+  #
+  class Stylesheet
+    # GC-managed compiled handle.
+    class Handle < ::FFI::AutoPointer
+      def self.release(ptr)
+        Leptris::XML::FFI.leptris_xslt_free(ptr)
+      end
+    end
+
+    # Compile a stylesheet. Raises XPathError on a stylesheet syntax
+    # error (detail on the thread-global last error).
+    def self.parse(stylesheet_xml)
+      raw = Leptris::XML::FFI.leptris_xslt_parse(
+        stylesheet_xml.to_s, stylesheet_xml.to_s.bytesize)
+      if raw.null?
+        raise Leptris::XML::XPathError,
+          "stylesheet parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+      end
+      new(Handle.new(raw))
+    end
+
+    # Compile from a file. Resolves §2.7 embedded stylesheets
+    # (xml-stylesheet PI with an href="#id" fragment) when the file's
+    # root is not itself a stylesheet.
+    def self.parse_file(path)
+      raw = Leptris::XML::FFI.leptris_xslt_parse_file(path.to_s)
+      if raw.null?
+        raise Leptris::XML::XPathError,
+          "stylesheet parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+      end
+      new(Handle.new(raw))
+    end
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    # Apply to +document+ (not modified) and return the result tree
+    # as an owning Document — query it with xpath/css like any other.
+    def apply_to(document)
+      raw = Leptris::XML::FFI.leptris_xslt_apply(@handle, document.c_ptr)
+      if raw.null?
+        raise Leptris::XML::XPathError,
+          "transform failed: #{document.last_error || Leptris::XML::FFI.leptris_last_error}"
+      end
+      Leptris::XML::Document.wrap(raw)
+    end
+
+    # Apply and serialize in one call — keeps top-level text nodes and
+    # result fragments that the tree API would flatten.
+    def serialize(document)
+      str_ptr = Leptris::XML::FFI.leptris_xslt_apply_string(
+        @handle, document.c_ptr)
+      Leptris::XML::FFI.read_owned_string(str_ptr)
+    end
+  end
+end

data/lib/leptris/xml.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Leptris
+  module XML
+    autoload :FFI, "leptris/xml/ffi"
+    autoload :Node, "leptris/xml/node"
+    autoload :Element, "leptris/xml/element"
+    autoload :Text, "leptris/xml/text"
+    autoload :Comment, "leptris/xml/comment"
+    autoload :CDATA, "leptris/xml/cdata"
+    autoload :ProcessingInstruction, "leptris/xml/processing_instruction"
+    autoload :EntityReference, "leptris/xml/entity_reference"
+    autoload :Attr, "leptris/xml/attr"
+    autoload :Namespace, "leptris/xml/namespace"
+    autoload :Document, "leptris/xml/document"
+    autoload :DocumentFragment, "leptris/xml/document_fragment"
+    autoload :DocType, "leptris/xml/doc_type"
+    autoload :NodeSet, "leptris/xml/node_set"
+    autoload :Searchable, "leptris/xml/searchable"
+    autoload :ParseOptions, "leptris/xml/parse_options"
+    autoload :CssToXPath, "leptris/xml/css_to_xpath"
+    autoload :CStringArray, "leptris/xml/c_string_array"
+    autoload :Serialization, "leptris/xml/serialization"
+    autoload :SAX, "leptris/xml/sax"
+    autoload :XPath, "leptris/xml/xpath"
+    autoload :EvaluationContext, "leptris/xml/evaluation_context"
+    autoload :Schematron, "leptris/xml/schematron"
+    autoload :Diff, "leptris/xml/diff"
+    autoload :Descriptor, "leptris/xml/descriptor"
+    autoload :PlanValue, "leptris/xml/plan_value"
+    autoload :IterationScope, "leptris/xml/iteration_scope"
+    autoload :ResultText, "leptris/xml/result_text"
+    autoload :ResultAttr, "leptris/xml/result_attr"
+    autoload :XSLT, "leptris/xml/xslt"
+    autoload :XQuery, "leptris/xml/xquery"
+    autoload :RelaxNG, "leptris/xml/relaxng"
+    autoload :Pull, "leptris/xml/pull"
+    autoload :Iterparse, "leptris/xml/iterparse"
+
+    # Nokogiri-style top-level entry points (Nokogiri::XML(...) /
+    # Nokogiri::XML.parse). Delegates to Document.parse.
+    def self.parse(xml_or_io, options: nil, readonly: false, recover: false)
+      Document.parse(xml_or_io, options: options, readonly: readonly,
+                     recover: recover)
+    end
+
+    # Tree diff between two documents: equal subtrees prune in
+    # O(1) by content digest; diverging regions align by LCS.
+    # +ignore_ws+ treats whitespace-only text nodes as absent.
+    def self.diff(document_a, document_b, ignore_ws: false)
+      Leptris::XML::Diff.compute(document_a, document_b,
+                                 ignore_ws: ignore_ws)
+    end
+
+    # Does +string+ contain a named entity reference that is not
+    # one of the five predefined XML entities (nor numeric)? One C
+    # pass (libleptris 1.9.62) — downstream adapters use it to skip
+    # whole-buffer rewrites when a document is already clean.
+    def self.buffer_has_nonstandard_entity?(string)
+      string = string.to_s
+      Leptris::XML::FFI.leptris_str_has_nonstandard_entity(
+        string, string.bytesize) != 0
+    end
+
+    # Tolerant HTML parse into a standard Document (libleptris
+    # 1.9.75): implied end tags, void elements, raw-text script and
+    # style, lowercased names, minimized/unquoted attributes, and
+    # the HTML named entities. html/head/body are synthesized; no
+    # implied tbody. Malformed input degrades to text rather than
+    # raising; only an entirely empty result is an error.
+    #
+    # MODES (libleptris 1.9.104, #659): :html4 (the default) pins
+    # the libxml2/Nokogiri compatibility shape — leading
+    # script/style stay in <body>, title/meta/link/base still lift
+    # — so byte-parity with Nokogiri::HTML holds. :whatwg selects
+    # the conformant engine: the full implied-<head> set
+    # (script/style/noscript/template/... lift) and foster
+    # parenting (1.9.105) — html5lib corpus 294/1555 vs Nokogiri's
+    # 372; the shapes genuinely differ by spec.
+    def self.parse_html(html, mode: :html4)
+      html = html.to_s
+      entry =
+        case mode
+        when :html4 then Leptris::XML::FFI.method(:leptris_parse_html4_string)
+        when :whatwg then Leptris::XML::FFI.method(:leptris_parse_html_string)
+        else
+          raise ArgumentError,
+            "mode must be :html4 or :whatwg, got #{mode.inspect}"
+        end
+      raw = entry.call(html, html.bytesize, nil)
+      if raw.null?
+        raise Leptris::XML::ParseError,
+          "HTML parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+      end
+      Leptris::XML::Document.wrap(raw)
+    end
+
+    def self.parse_file(path)
+      Document.parse_file(path)
+    end
+
+    class Error < StandardError; end
+    class ParseError < Error; end
+    class ReadOnlyError < Error; end
+    class XPathError < Error; end
+    class UseAfterFreeError < Error; end
+  end
+end

data/lib/leptris.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "leptris/version"
+
+module Leptris
+  autoload :XML, "leptris/xml"
+end
+
+# Eager library resolution (issue leptris-ruby#49): resolve the
+# native library at require time instead of lazily inside
+# Document.parse, so a missing library fails immediately.
+#
+# The require MUST come after the autoload registration above.
+# ffi.rb opens `module Leptris; module XML`, and when that runs
+# before `autoload :XML` exists it creates the constant first — the
+# later autoload registration is then shadowed, xml.rb never loads,
+# and the entire API is unreachable (Leptris::XML.constants ==
+# [:FFI]; issue leptris-ruby#53). Requiring from here after the
+# registration makes ffi.rb's module opening trigger the autoload,
+# landing FFI inside the real manifest module; a downstream
+# `require "leptris/xml"` is then a no-op.
+begin
+  require "leptris/xml/ffi"
+rescue LoadError => e
+  raise LoadError, <<~MSG
+    Leptris could not load the native libleptris library.
+    The ruby-platform gem is a fallback variant and ships no
+    binary; install the platform-specific variant for your system
+    (e.g. `gem install leptris --platform=arm64-darwin`), or set
+    LEPTRIS_LIB_PATH to a libleptris.{so,dylib,dll} file.
+    (Underlying error: #{e.message})
+  MSG
+end
+
+# TODO.perf/02: auto-enable the native acceleration layer when the
+# compiled bundle is present (platform gems). Quietly falls back
+# to pure FFI when absent (ruby-variant on TruffleRuby/JRuby,
+# custom builds). LEPTRIS_NO_NATIVE=1 forces the FFI path (the
+# suite uses it to exercise both surfaces). The explicit
+# `require "leptris/xml/native_layer"` remains the parallel-API
+# entry for NativeNode builders.
+unless ENV["LEPTRIS_NO_NATIVE"] == "1"
+  begin
+    require "leptris/xml/native_layer"
+  rescue LoadError => e
+    # #207: a silent fallback hides a platform-gem packaging bug
+    # behind a walk-speed regression. Say so, then continue on
+    # the FFI surface (the explicit require still raises its full
+    # error for callers that opt in).
+    warn "leptris: native acceleration unavailable " \
+         "(#{e.message.gsub(/\s+/, ' ').strip[0, 200]}); using the FFI surface"
+  end
+end

data/scripts/gem_smoke.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Post-publish smoke (the teptris-ruby gem-smoke template): the
+# INSTALLED gem from rubygems — not the checkout — must parse,
+# query, mutate, serialize, and validate, with the native layer
+# when the platform ships it. Also guards the #318 class: the
+# NODE_* constants must exist in the shipped layer (a packaging
+# skew surfaces as a NameError on first use, not at require).
+require "leptris"
+
+abort "SMOKE FAIL: leptris did not define Leptris::VERSION" unless defined?(Leptris::VERSION)
+puts "leptris #{Leptris::VERSION} on #{RUBY_PLATFORM} (ruby #{RUBY_VERSION})"
+
+doc = Leptris::XML.parse("<r id='1'><a x='2'>t1</a><a>t2</a></r>")
+raise "parse: root" unless doc.root.name == "r"
+raise "xpath: children" unless doc.root.xpath("a").size == 2
+raise "attr read" unless doc.at_xpath("a")["x"] == "2"
+
+doc.at_xpath("a").content = "z"
+raise "mutate" unless doc.at_xpath("a").content == "z"
+raise "serialize" unless doc.to_xml.include?('<a x="2">z</a>')
+
+rng = Leptris::XML::RelaxNG.parse(
+  '<element name="r" xmlns="http://relaxng.org/ns/structure/1.0">' \
+  "<attribute name=\"id\"/></element>")
+rng_doc = Leptris::XML::Document.parse(%q{<r id='1'/>})
+raise "rng verdict" unless rng.valid?(rng_doc)
+raise "rng errors shape" unless rng.validate_errors(rng_doc).is_a?(Array)
+raise "rng report shape" unless rng.validate_report(rng_doc).is_a?(Array)
+
+# The #318 class: node-kind constants must live in the shipped
+# Ruby layer (plain constants cannot go missing with the lib).
+raise "NODE constants" unless Leptris::XML::FFI::NODE_ELEMENT
+
+layer = defined?(Leptris::XML::NATIVE_FAST) ? "native" : "ffi"
+puts "SMOKE OK (#{layer} layer)"

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: leptris
+version: !ruby/object:Gem::Version
+  version: 1.9.197.2
+platform: arm-linux
+authors:
+- Ribose Inc.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Leptris is a Nokogiri-compatible Ruby binding for libleptris, a pure-C99 XML
+  1.0 parser with full XPath 1.0 and SAX support. The C DOM is the single
+  source of truth; Ruby objects are thin FFI wrappers (one Ruby method =
+  one FFI call).
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CLAUDE.md
+- CONTEXT.md
+- LICENSE.md
+- README.adoc
+- Rakefile
+- TODO.perf/01-ext-accelerated-default-reads.md
+- TODO.perf/02-auto-enable-native-layer.md
+- TODO.perf/03-bulk-xpath-result-materialization.md
+- TODO.perf/04-ext-bound-serialization.md
+- TODO.perf/05-native-surface-completion.md
+- TODO.perf/06-perf-battery-native-legs.md
+- TODO.perf/07-native-read-floor.md
+- TODO.perf/08-version-coherent-native-mutations.md
+- TODO.perf/09-adoption-lift-fast-path.md
+- TODO.perf/10-bulk-attribute-materialization.md
+- TODO.perf/11-moxml-gap-battery.md
+- TODO.perf/12-document-lifetime-in-c.md
+- TODO.perf/13-structural-memos.md
+- TODO.perf/14-insert-family-c-bound.md
+- TODO.perf/15-compiled-expression-cache.md
+- TODO.perf/16-at-xpath-single-result-seam.md
+- TODO.perf/17-precomputed-fast-path-flags.md
+- TODO.perf/18-inner-html-one-c-pass.md
+- TODO.perf/19-lazy-node-pointer.md
+- TODO.perf/20-css-translation-cache.md
+- TODO.perf/21-key-memo-consult.md
+- TODO.perf/22-eager-nodeset-materialization.md
+- TODO.perf/23-cbound-value-mutations.md
+- TODO.perf/24-immutable-read-lanes.md
+- TODO.perf/25-scope-owned-bulk-path.md
+- TODO.perf/26-post-mutation-memo-seeding.md
+- TODO.perf/27-c-yield-traversal.md
+- TODO.perf/28-address-fills.md
+- TODO.perf/29-ns-xpath-compiled.md
+- TODO.perf/30-copy-and-element-child-faces.md
+- TODO.perf/31-battery-rounds-4-8.md
+- TODO.perf/32-clean-host-floor-table.md
+- TODO.perf/33-cbound-root-set.md
+- TODO.perf/34-fragment-fast-lane.md
+- TODO.perf/35-parse-default-c-face.md
+- TODO.perf/36-raise-in-c-serializer-encoding.md
+- TODO.perf/37-document-lazy-pointer.md
+- TODO.perf/38-bulk-walk-and-bench-gate.md
+- TODO.restructure/01-constraint-compliance-audit.md
+- TODO.restructure/02-deep-copy-seam.md
+- TODO.restructure/03-evaluation-context-seam.md
+- TODO.restructure/04-spec-mece-restructure.md
+- TODO.restructure/05-memory-documentation.md
+- TODO.restructure/06-architecture-map-refresh.md
+- TODO.restructure/07-external-gates.md
+- TODO.restructure/08-new-code-audit-and-ext-memo.md
+- TODO.restructure/09-iteration-scope.md
+- TODO.restructure/10-cold-attr-read-diet.md
+- TODO.restructure/11-construction-factory-diet.md
+- TODO.restructure/12-resultattr-merge.md
+- TODO.restructure/13-spec-mece-followup.md
+- TODO.restructure/14-constraint-audit-refresh.md
+- TODO.restructure/15-readme-feature-documentation.md
+- TODO.restructure/16-claudemd-map-refresh.md
+- TODO.restructure/17-perf-drift-record.md
+- TODO.restructure/18-audit-spec-doubles-and-gem-contents.md
+- TODO.restructure/19-gitignore-hygiene.md
+- TODO.restructure/20-utf8proc-enablement.md
+- TODO.restructure/21-typeddata-variant-prototype.md
+- TODO.restructure/22-sax-drain-bulk-strip.md
+- docs/adr/0001-lockstep-mirror.md
+- docs/adr/0002-utf8-at-the-seam.md
+- docs/adr/0003-readonly-memoization-pattern.md
+- docs/adr/0004-lifetime-guard.md
+- docs/adr/0005-autoload-manifest-ordering.md
+- docs/adr/0006-ruby-variant-policy.md
+- ext/build_windows_native.rb
+- ext/leptris/native/extconf.rb
+- ext/leptris/native/native.c
+- leptris.gemspec
+- lib/leptris.rb
+- lib/leptris/version.rb
+- lib/leptris/xml.rb
+- lib/leptris/xml/attr.rb
+- lib/leptris/xml/c_string_array.rb
+- lib/leptris/xml/cdata.rb
+- lib/leptris/xml/comment.rb
+- lib/leptris/xml/css_to_xpath.rb
+- lib/leptris/xml/descriptor.rb
+- lib/leptris/xml/diff.rb
+- lib/leptris/xml/doc_type.rb
+- lib/leptris/xml/document.rb
+- lib/leptris/xml/document_fragment.rb
+- lib/leptris/xml/element.rb
+- lib/leptris/xml/entity_reference.rb
+- lib/leptris/xml/evaluation_context.rb
+- lib/leptris/xml/ffi.rb
+- lib/leptris/xml/iteration_scope.rb
+- lib/leptris/xml/iterparse.rb
+- lib/leptris/xml/namespace.rb
+- lib/leptris/xml/native.so
+- lib/leptris/xml/native_layer.rb
+- lib/leptris/xml/node.rb
+- lib/leptris/xml/node_set.rb
+- lib/leptris/xml/parse_options.rb
+- lib/leptris/xml/plan_value.rb
+- lib/leptris/xml/processing_instruction.rb
+- lib/leptris/xml/pull.rb
+- lib/leptris/xml/relaxng.rb
+- lib/leptris/xml/result_attr.rb
+- lib/leptris/xml/result_text.rb
+- lib/leptris/xml/sax.rb
+- lib/leptris/xml/sax/document.rb
+- lib/leptris/xml/sax/dom_dispatch.rb
+- lib/leptris/xml/sax/parser.rb
+- lib/leptris/xml/sax/recorder.rb
+- lib/leptris/xml/schematron.rb
+- lib/leptris/xml/searchable.rb
+- lib/leptris/xml/serialization.rb
+- lib/leptris/xml/text.rb
+- lib/leptris/xml/xpath.rb
+- lib/leptris/xml/xquery.rb
+- lib/leptris/xml/xslt.rb
+- lib/libleptris.so
+- lib/libutf8proc.so.3
+- scripts/gem_smoke.rb
+homepage: https://github.com/leptris/leptris-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/leptris/leptris-ruby
+  source_code_uri: https://github.com/leptris/leptris-ruby
+  changelog_uri: https://github.com/leptris/leptris-ruby/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Nokogiri-compatible Ruby binding for libleptris (XML 1.0, XPath 1.0, SAX)
+test_files: []