makiri 0.16.0-aarch64-linux → 0.17.0.rc1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 651fa28c960d1fd0099870394fc7f19bef09e328ac4851d7102ebfbf9136a6a7
-  data.tar.gz: e84db4b38c9fbe3184b90cee36976b005521dfdca1165d10adf1c70970a36918
+  metadata.gz: 8710995de3498cde22ec02966971c541ba7ba3f2c9176be2566c93008bdcd82d
+  data.tar.gz: b6fd0ff75de338b8cab9b7c3ec74edd471ba64c17094ebcb50e3432818820172
 SHA512:
-  metadata.gz: 9d9e73501a9744ecf0b16610f52cdf0f8ed17473914654b5bf719cdf3e84fd333cbe77f12305b0d0be9d52da6a9652a659c7a970e0a6e317a98edbe8b4c84b6c
-  data.tar.gz: 11627962979c3a7649f3ce09fc4bd5b7bc019626c675263ae73bae9434ebd003b565d9726bb0e8d0d497c80c01bbebfd79c0b677e40f894dcbad1135749b7e53
+  metadata.gz: 173b0f7471ff9c615421b91ab848326990b8c9706c54cbc2049b216b1d71c15147b950f73a323ddb2e13a0580d7644453a61476cff46952cf4419c25233a2d95
+  data.tar.gz: 63d50aab4ee8a15570215b275a566d1dbbc1b11ad22551564cc5e790821711ea57feee4432c1bf28e18a3c1e2aa0251b6a30433df562aae7cfd84e6b580acfb8

data/CHANGELOG.md

@@ -1,5 +1,94 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.17.0.rc1] - 2026-10-22
+
+### Added
+
+* `Makiri::Lexbor::CSS.parse_stylesheet` returns the declarations in an
+  at-rule's block (`@font-face`, `@page`, ...) as its `:declarations`; they
+  were dropped.
+
+### Changed
+
+* HTML is parsed by Makiri's own Rust port of Lexbor's tokenizer and tree
+  builder, into a DOM of Makiri's own, and the CSS selector and stylesheet
+  parsers are ported too. A parsed document takes about 40% less memory.
+* Installing from source needs Rust 1.84 or newer (and libclang), and no
+  longer CMake: the gem carries none of Lexbor's sources, only its LICENSE
+  and NOTICE.
+* `Makiri::XML`'s `#css`, `#at_css` and `#matches?` run on the same matcher
+  as HTML's and answer as a browser's `querySelectorAll` does in an XML
+  document, 10-20x faster on compound selectors (`.item`, `ul li.item`).
+  This changes some answers:
+  * a bare type selector (`p`) matches that name in any namespace;
+  * the root element's namespace declarations are no longer picked up: a
+    prefix must be given in the ns Hash, whose `"xmlns"` entry is the
+    default namespace (on HTML too);
+  * a selector run on a node may match through ancestors outside it
+    (`node.css("body p")`); only the node's descendants are returned;
+  * `[a=v i]`, `:nth-child(... of S)`, and the form-state and link
+    pseudo-classes on XHTML elements are supported;
+  * `||` and `:current()` raise `Makiri::CSS::SyntaxError`, and an over-long
+    chain `Makiri::Error` (it was `Makiri::XPath::LimitExceeded`).
+* HTML `css(selector, ns)` resolves namespace prefixes: `svg|path` is the SVG
+  `path`, `|p` an element in no namespace, `[x|href]` the attribute in `x`'s
+  namespace. A prefix the Hash does not bind raises
+  `Makiri::CSS::SyntaxError`; prefixes used to be ignored.
+* HTML parsing follows the HTML Standard where Lexbor did not. This affects
+  malformed or unusual markup only: `<frameset>`, `<form>` and tables inside
+  `<template>`, `<![CDA` or `<!` at the end of the input, the adoption
+  agency, `<textarea>`, `<input type=HIDDEN>` and `<image>` in a table,
+  `<sup>` in SVG or MathML, and a repeated attribute name (the first is
+  kept). Fragment parsing (`#inner_html=`, `#outer_html=`, `Node#parse`,
+  `context:` given an element) takes the context element's quirks mode,
+  namespace and ancestor `<form>` into account, as browsers do.
+* CSS selectors are parsed as Selectors 4 says: `:has()` inside `:has()` and
+  an invalid argument to `:has()` make the selector invalid, an empty
+  `:is()` / `:where()` is valid and matches nothing, and `#1a` is not an ID
+  selector.
+* `parse_stylesheet` reads names and values by one rule for every property: a
+  declaration name is lower-cased unless it is a custom property, an at-rule
+  name is lower-cased, and a value is the text as written with whitespace
+  runs collapsed (`color: RED` stays `RED`; it came back as `red`).
+  `:specificity` is counted as Selectors 4 does (`:is()` / `:not()` /
+  `:has()` take their most specific argument).
+
+### Removed
+
+* The 10,000-`<option>` limit on a `<select>`: a select with any number of
+  options parses in linear time, as browsers parse it.
+
+### Fixed
+
+* `parse_stylesheet` keeps a rule such as `a:hover { ... }` inside `@media`
+  or `@supports`; it was read as a declaration, which dropped that rule and
+  every one after it in the block. A comment between a declaration's name
+  and its `:` no longer drops the declarations that follow.
+* A namespaced type selector in the middle of a compound (`.x|a`) raises
+  `Makiri::CSS::SyntaxError`, as browsers do.
+* `:any-link` / `:link` match only an HTML `a` or `area`, or an SVG `a`, with
+  an `href` (`<link href>` and `<map>` matched). `:read-write` /
+  `:read-only` follow the HTML Standard (a checkbox is read-only, an element
+  inside `contenteditable` is read-write), and `:empty` ignores processing
+  instructions.
+* HTML's `:nth-child` family counts element siblings only:
+  `html:first-child` matched nothing after `<!doctype html>`.
+* An attribute keeps the namespace it was made in: `set_attribute_ns` in the
+  element's own namespace replaces the attribute it set before instead of
+  adding a second, and an attribute removed from its element keeps its
+  `namespace_uri`.
+* An attribute name is serialized in the case it was set (`e["viewBox"]` on
+  an element in no namespace was written lower-cased).
+* A void element's `#inner_html` is empty even when it has children, and a
+  prefixed HTML, SVG or MathML element is written by its local name.
+* `Node#line` of a void element fostered out of a table is its line, not nil.
+* Many namespaces created with `create_element_ns` no longer make lookups
+  quadratic.
+* `HTML::Document#import_node` given a document raises "cannot import a
+  document; use #dup", as `#clone_node` does.
+
 ## [0.16.0] - 2026-10-10
 
 ### Added

data/NOKOGIRI_DIFFERENCES.md

@@ -149,7 +149,7 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
 * `<?php ... ?>` in HTML input is a **ProcessingInstruction** node; `#to_html`
   writes it back as `<?php ... ?>`, and `<?` at end of input is ignored.
   * The HTML Standard added processing-instruction tokens and tree-construction
-    rules for them; Makiri follows them through Lexbor. `Nokogiri::HTML5` (gumbo)
+    rules for them, and Makiri's parser follows them. `Nokogiri::HTML5` (gumbo)
     still produces the older bogus comment (`<!--?php ... ?-->`), and
     `Nokogiri::HTML` (libxml2) its own comment.
 
@@ -158,17 +158,14 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   Nokogiri's. `inner_html=`, `outer_html=` and `Node#parse` take no keyword.
   `Nokogiri::HTML` (libxml2) instead stops at depth 256 and returns the
   truncated document.
-* More than 10,000 `<option>`s in one `<select>` raise `Makiri::Error`;
-  Nokogiri has no such limit.
 
 ## HTML mutation
 
 * There is no `Node#name=` / `#node_name=` (on HTML or XML nodes). Nokogiri
   renames a node in place and keeps its identity; the DOM has no rename, and
-  Lexbor keeps elements such as `<template>`, `<option>` and `<style>` in
-  structs of their own, so a node cannot change its tag safely. Create an
-  element of the new name, move the attributes and children, and `replace`
-  the old one (see CHANGELOG.md).
+  an element's tag decides what it is (a `<template>` owns its contents), so a
+  node cannot change its tag. Create an element of the new name, move the
+  attributes and children, and `replace` the old one (see CHANGELOG.md).
 * Element and attribute names follow the WHATWG DOM's rules
   * `create_element`, `[]=` and `set_attribute_ns` raise `ArgumentError` for a
     name the DOM refuses - one holding whitespace, `/`, `>` (or `=` for an
@@ -224,26 +221,19 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   * One exception to the DOM: an HTML attribute named `xml:lang` (in no
     namespace) becomes the XML namespace's `xml:lang`, as the XML reader reads
     that name, so XHTML-style HTML still writes as XML.
-* A known gap, in Lexbor's tag table: an HTML document that already holds a
-  parsed element named with a colon (`<x:y>`, one local name) and then
-  receives, by `import_node` from another document, a prefixed element
-  written the same way (`x:y` from XML: prefix `x`, local name `y`) re-points
-  the table's entry for that spelling - the parsed element then no longer
-  matches CSS `x\:y`. Copies within one document do not touch the table.
 * An XML element with a prefix, imported into HTML, keeps it (`h:div` in
   XHTML has the local name `div`). Two readers then disagree, as they do in
-  browsers: CSS's `div` matches it (Lexbor matches the local name), XPath's
-  `//div` does not (an HTML element's name test reads its qualified name). And
-  Lexbor's HTML serializer writes the prefix (`<h:div>`), where the HTML
-  standard writes the local name, so the HTML does not re-parse to the same
-  element.
+  browsers: CSS's `div` matches it (the matcher compares the local name),
+  XPath's `//div` does not (an HTML element's name test reads its qualified
+  name). `#to_html` writes the local name (`<div>`), as the HTML standard
+  does.
 
 ## CSS
 
 * Most jQuery/Nokogiri CSS extensions are not supported (`:gt`, `:lt`, `:eq`, `:first`, ...)
-  * Makiri uses Lexbor's selector engine, which is standards-based apart from one
-    text-containment extension. Use XPath (`xpath("//p[contains(., 'x')]")`) or
-    Enumerable (`css('li')[1]`) for the rest.
+  * Makiri's selector engine is standards-based. Use XPath
+    (`xpath("//p[contains(., 'x')]")`) or Enumerable (`css('li')[1]`) for the
+    rest.
     Standard Level-4 selectors (`:is` / `:where` / `:has`) are supported; some of which Nokogiri rejects.
   * There is no text-containment pseudo-class. Nokogiri's `:contains()` is
     not supported, and neither is Lexbor's `:lexbor-contains()`: it raises
@@ -255,33 +245,45 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   selector) is supported and correct on both HTML and XML - the "type" is the
   element's own expanded name.
   * Nokogiri (XML and HTML5) mistranslates these to first-/only-child
-    (`//*[position()=1]` / `//*[last()=1]`), so it under-matches; Makiri matches
-    Lexbor's HTML matcher.
-* HTML CSS takes a `{prefix => uri}` Hash (`css(selector, ns)`) but does not
-  resolve prefixes against it: Lexbor's matcher matches a prefixed type selector
-  loosely, so `svg|path`, `|path` and `path` all find the SVG element whatever
-  is bound. `Nokogiri::HTML5` honours the binding (a wrong URI finds nothing).
-  * The Hash is accepted and unused rather than refused, so the `css(selector,
-    ns)` a caller writes for both representations works. Use `#xpath`, where a
-    prefix IS resolved against the bindings, when the namespace matters.
-  * `Makiri::XML` resolves CSS prefixes properly - it lowers the selector to the
-    XPath engine, which registers the bindings.
-  * The same holds for attribute selectors: HTML `[|href]` (no namespace) and
-    plain `[href]` also find an SVG `xlink:href`, which `Nokogiri::HTML5`
-    does not.
-    `Makiri::XML` reads `[|a]` as the no-namespace attribute.
+    (`//*[position()=1]` / `//*[last()=1]`), so it under-matches; Makiri does
+    not.
+* CSS resolves a namespace prefix against the `{prefix => uri}` Hash
+  (`css(selector, ns)`), on HTML and XML alike: `svg|path` is the SVG `path`
+  once `svg` is bound, `|path` an element in no namespace, and a prefix the
+  Hash does not bind raises `Makiri::CSS::SyntaxError`. `[x|href]` finds the
+  XLink `href` once `x` is bound to XLink. The Hash's `"xmlns"` entry is the
+  default namespace, as CSS `@namespace` without a prefix sets one: a type or
+  universal selector without a prefix is then in it.
+  * Without a default, a bare type selector matches its name in any namespace
+    (`path` finds the SVG element, `entry` an Atom entry), as a browser's
+    `querySelectorAll` does. `Nokogiri::XML` binds a bare name to the root's
+    default namespace when no Hash is given, and to no namespace once one is;
+    pass `"xmlns" => uri` (or `"xmlns" => ""`) for that reading.
+  * `Makiri::XML` does not collect the document's own declarations: a prefix
+    is declared by the Hash or not at all. `Nokogiri::XML` collects the
+    root's.
+  * A bare `*` under a default namespace is in it, as CSS has it;
+    `Nokogiri::XML` matches any element.
+  * Up to 0.16 HTML accepted the Hash and ignored every prefix, and
+    `Makiri::XML` collected the root's declarations as Nokogiri does.
 * A selector under a node matches the way `Element#querySelectorAll` does in a
-  browser, not scoped to that node, on HTML: `at_css("#c").css("div p")` finds a
-  `p` inside `#c` when `#c` is itself a `div`, since the selector is matched
-  against the whole document and only the results are kept to descendants.
-  `Nokogiri::HTML5` and `Nokogiri::XML` scope the selector to the node (`#c`
-  cannot be the `div`), and so does `Makiri::XML`, which lowers the selector to
-  an XPath from the node. Lexbor has no `:scope`; for a scoped match on HTML,
-  use XPath from the node (`xpath(".//div//p")`).
-* The attribute case modifiers (`[a="x" i]`, `[a="x" s]`): HTML supports both,
-  through Lexbor's matcher. `Makiri::XML` accepts `s` (case-sensitive, which XML
-  values are anyway) and refuses `i` with `Makiri::CSS::SyntaxError`. Nokogiri
-  refuses both on either representation.
+  browser, not scoped to that node, on HTML and XML alike:
+  `at_css("#c").css("div p")` finds a `p` inside `#c` when `#c` is itself a
+  `div`, since the selector is matched against the whole tree and only the
+  results are kept to descendants. `Nokogiri::HTML5` and `Nokogiri::XML` scope
+  the selector to the node (`#c` cannot be the `div`), and so did
+  `Makiri::XML` up to 0.16. There is no `:scope`; for a scoped match, use XPath
+  from the node (`xpath(".//div//p")`).
+* The attribute case modifiers (`[a="x" i]`, `[a="x" s]`) are supported on
+  both representations. Nokogiri refuses both on either.
+* The form-state and link pseudo-classes (`:checked`, `:disabled`,
+  `:enabled`, `:required`, `:optional`, `:placeholder-shown`, `:link`, ...)
+  answer on `Makiri::XML` too, for XHTML elements, as browsers do in an XML
+  document; on any other element they match nothing. `Nokogiri::XML` refuses
+  them.
+* A selector `Makiri` cannot run (the column combinator `||`, `:current()`)
+  raises `Makiri::CSS::SyntaxError`, as a browser's `querySelectorAll` throws a
+  SyntaxError, on both representations.
 * `#matches?` answers for a DETACHED node (`document.create_element("p")
   .matches?("p")` is true, on both representations). Nokogiri raises
   `NoMethodError` there - it implements `#matches?` as a search from
@@ -294,7 +296,9 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   therefore matches no type selector.
   * `Nokogiri::HTML5` is case-sensitive on HTML elements too, so `LI` does not
     match `<li>` there. `Makiri::XML`'s `#css` is case-sensitive, as XML names
-    are.
+    are - an XHTML element's included, as in a browser's XML document - and so
+    are its attribute values, the HTML Standard's case-insensitive list of
+    attributes applying only to an HTML document.
 
 ## Serialization
 

data/NOTICE

@@ -8,6 +8,13 @@ This product includes software developed by:
   Licensed under the Apache License, Version 2.0
   https://lexbor.com / https://github.com/lexbor/lexbor
 
+  The HTML tokenizer and tree builder under ext/makiri/rust/src/html/ and the
+  CSS syntax, selector and stylesheet parser under
+  ext/makiri/rust/src/selectors/ are Rust ports of Lexbor's, as are the HTML
+  CSS matcher under ext/makiri/rust/src/css_match/ and the tag and
+  attribute tables generated from Lexbor's. The extension links no Lexbor
+  code; Lexbor's LICENSE and NOTICE are kept under vendor/lexbor/ in the gem.
+
 The XPath 1.0 engine under ext/makiri/rust/src/xpath/ is an original
 implementation written for this project. No code is derived from libxml2 or
 libxslt.

data/README.md

@@ -28,8 +28,7 @@ XPath 1.0 evaluation in its own native engine, with no libxml2 dependency.
     differential, and property-based testing vs Nokogiri (see below).
 * Bounded, fail-closed execution
   * XPath evaluation is bounded by per-evaluation limits on work, memory, and recursion.
-  * HTML parsing bounds the tree depth (`max_tree_depth:`, default 400) and the
-    `<option>`s per `<select>` (10,000).
+  * HTML parsing bounds the tree depth (`max_tree_depth:`, default 400).
   * Ownership and borrowing are kept explicit across layers, with owned/borrowed
     string types and verified text at engine boundaries.
   * Programmatic invalid input, limit violations, allocation failures, and unsupported constructs
@@ -109,9 +108,10 @@ el = doc.at_xpath("//a:entry", ns)
 el.local_name                                  # => "entry"
 el.namespace_uri                               # => "http://www.w3.org/2005/Atom"
 
-# CSS selectors work too (lowered to the native XPath engine): a bare type
-# selector binds to the document's default namespace, so this just works.
+# CSS selectors work too, as in a browser: a bare type selector matches its
+# name in any namespace, so this just works.
 doc.css("entry").length                        # => 2
+doc.css("a|entry", ns).length                  # => 2 (a prefix the Hash binds)
 doc.css("feed > entry").map { |e| e.at_css("title").text }  # => ["Hello", "World"]
 
 # Serialize back to XML
@@ -256,10 +256,13 @@ See also [`spec/conformance/README.md`](spec/conformance/README.md).
 ## Requirements
 
 * CRuby 3.2 or newer.
-* A Rust toolchain (stable) with `cargo` - the extension is a Rust crate.
+* Rust 1.84 or newer with `cargo` - the extension is a Rust crate. (Binary
+  gems are published for the common platforms, which need no toolchain.)
 * libclang (clang's development library): rb-sys runs bindgen at build time and
   reads Ruby's headers through it.
-* CMake and a C toolchain, to build the vendored Lexbor static library.
+
+Development also needs CMake and a C toolchain, to build the vendored Lexbor
+that the Rust port is tested against (`rake lexbor`).
 
 ## Build (development)
 

data/lib/makiri/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Makiri
-  VERSION = "0.16.0"
+  VERSION = "0.17.0.rc1"
 end

data/lib/makiri/xml/node_methods.rb

@@ -28,30 +28,33 @@ module Makiri
       # After #key?, which #has_attribute? aliases.
       ReaderAliases.define_on(self)
 
-      # CSS selector queries over XML, lowered to the native XPath engine (so
-      # matching is case-sensitive and namespace-aware, unlike a Lexbor HTML
-      # matcher). Nokogiri-compatible namespaces: the root element's
-      # declarations are collected automatically (a bare type selector binds to
-      # the default namespace), unless an +ns+ hash of {prefix => uri} is
-      # given, which then replaces them.
+      # CSS selector queries over XML, matched by the same engine as HTML's,
+      # as a browser's querySelectorAll matches them in an XML document: names
+      # and values compare as written, a type selector without a prefix
+      # matches its name in any namespace, and the context node's ancestors
+      # take part in the match while only its descendants are returned. An
+      # +ns+ hash of {prefix => uri} declares the prefixes the selector may
+      # use; its "xmlns" entry, if any, is the default namespace a bare type
+      # selector is then in.
       #
-      #   doc.css("entry")               # default-namespace bound (Atom/RSS just work)
-      #   doc.css("a|entry", "a" => uri) # explicit prefix
+      #   doc.css("entry")                    # <entry> in any namespace
+      #   doc.css("a|entry", "a" => uri)      # <entry> in uri
+      #   doc.css("entry", "xmlns" => uri)    # the same, as a default
       #
       # @return [Makiri::NodeSet]
       def css(selector, ns = nil)
-        _css(selector.to_s, _css_namespaces(ns))
+        _css(selector.to_s, ns)
       end
 
       # First descendant matching +selector+, or nil. @return [Makiri::Node, nil]
       def at_css(selector, ns = nil)
-        _at_css(selector.to_s, _css_namespaces(ns))
+        _at_css(selector.to_s, ns)
       end
 
       # Whether this node matches +selector+ (full selector, combinators included).
       # @return [Boolean]
       def matches?(selector, ns = nil)
-        _css_matches(selector.to_s, _css_namespaces(ns))
+        _css_matches(selector.to_s, ns)
       end
 
       private
@@ -61,25 +64,6 @@ module Makiri
       def unprefixed_element_namespace
         nil
       end
-
-      # Build the {prefix => uri} hash the native primitives register. Matching
-      # Nokogiri: with NO explicit namespaces the document's own declarations are
-      # collected (the default namespace under the synthetic prefix "xmlns", so a
-      # bare type selector binds to it - the RSS/Atom common case); but once the
-      # caller passes a namespaces hash, ONLY those prefixes are used and a bare
-      # selector resolves to no namespace (Nokogiri disables the default binding
-      # the moment an explicit map is given). Reading only the root's
-      # declarations is O(root attributes), not the whole-document walk.
-      def _css_namespaces(user)
-        return user.transform_keys(&:to_s).transform_values(&:to_s) if user && !user.empty?
-
-        reg = {}
-        root = document&.root
-        root&.namespace_definitions&.each do |ns|
-          reg[ns.prefix.nil? ? "xmlns" : ns.prefix] = ns.href
-        end
-        reg
-      end
     end
   end
 end

data/vendor/lexbor/LICENSE

@@ -0,0 +1,223 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+
+Lexbor SUBCOMPONENTS:
+
+The Lexbor includes a number of subcomponents with
+separate copyright notices and license terms. Your use of the source
+code for the these subcomponents is subject to the terms and
+conditions of the following licenses. Paths are relative to the lexbor
+folder.
+
+Portions of source/lexbor/core/dtoa.h, source/lexbor/core/dtoa.c,
+source/lexbor/core/strtod.h, source/lexbor/core/strtod.c,
+source/lexbor/core/diyfp.h, source/lexbor/core/diyfp.c is based on
+NGINX NJS project (https://github.com/nginx/njs/) which is 
+available under BSD 2-clause "Simplified" License.
+
+BSD-2-Clause license.
+
+Copyright (C) 2015-2019 NGINX, Inc.
+Copyright (C) 2019-2025 F5, Inc.
+Copyright (C) 2015-2021 Igor Sysoev
+Copyright (C) 2017-2025 Dmitry Volyntsev
+Copyright (C) 2019-2022 Alexander Borisov
+Copyright (C) 2022-2025 Vadim Zhestikov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/lexbor/NOTICE

@@ -0,0 +1,16 @@
+
+   Lexbor.
+
+   Copyright 2018-2020 Alexander Borisov
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.