makiri 0.11.0.rc2-aarch64-linux → 0.12.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ae07343e3bef2660b0c03b331cfea39bbee2cb96b8ee6fd8cbfa1436aae7548
-  data.tar.gz: a4b45062e6de703bab9f32083fdf7d8d43dc15b3824cc163e02dcf03fb951e15
+  metadata.gz: dad06ebaa7e4fa5fec68080e1714a5be6b72dc89172ff5f1f7840d6e73f4cffe
+  data.tar.gz: fe535f36f6d2f28acd4b3bd6c40f2d2f5c1a288affe5dc94ddd22d520c4e8ae7
 SHA512:
-  metadata.gz: 7a7e3c6a4ddc8a880b5683d43f6d6a1ae466ab2df1aece77ca5b9c2cb5d863db95821d596ba81ee660353a9d470d3668f082ae498843215295f521c9d87db89c
-  data.tar.gz: 367a936fac3a3716675d9f70cad71414db03c6660cc2e1f5e08f7fee947308f3370c355a1dace43e85a2cc7e67c9e9cd9c2d573943e48b4528fca4e70ab6474e
+  metadata.gz: 444bfeb89cb88fe1e3bed19008401e0c8f09043e803722c4dac63c88063a53eaa8a9e097b08f5b11c25f83a76e4d5f7630d99846c4f1c9131feafb72351a17aa
+  data.tar.gz: c296890d6e35f332fb975542d2eebe5dd7b4283cbc3012715c43a37917aa82d40492136fe045ab44362e26572b09b3e1f9dc52b9f059d40d1fa93f3f25d5e11c

data/.github/workflows/css-match.yml

@@ -0,0 +1,180 @@
+name: CSS matcher
+
+# The HTML CSS matcher (`lexbor::css_match`) on its own: it answers every
+# `Node#css` / `#at_css` / `#matches?`, and its failure mode is not a crash
+# but a wrong answer, which the general suites only catch by example. Two
+# checks, both against the OLD engine - Lexbor's own `lxb_selectors`, kept as
+# `lexbor::selectors` for exactly this:
+#
+#   - the randomized differential tests in `lexbor::tests::css_match`, run long
+#     with a fresh seed (MAKIRI_CSS_DIFF_SEED; a failure prints it);
+#   - the cargo-fuzz targets `html_css` (memory safety, and the three entry
+#     points agreeing) and `html_css_diff` (agreement with Lexbor's engine),
+#     with the selector dictionary.
+#
+# A PR that touches the matcher, the Lexbor layer or the pin gets a short run;
+# the nightly one is long. A disagreement on a shape where css_match departs
+# from Lexbor on purpose is not a finding: the departures are listed in
+# `css_match`'s module doc, and both checks leave them out.
+
+on:
+  push:
+    branches: [main, master]
+    paths:
+      - "ext/makiri/rust/src/lexbor/**"
+      - "ext/makiri/rust/fuzz/**"
+      - "ext/makiri/rust/Cargo.toml"
+      - "vendor/lexbor"
+      - ".github/workflows/css-match.yml"
+  pull_request:
+    paths:
+      - "ext/makiri/rust/src/lexbor/**"
+      - "ext/makiri/rust/fuzz/**"
+      - "ext/makiri/rust/Cargo.toml"
+      - "vendor/lexbor"
+      - ".github/workflows/css-match.yml"
+  schedule:
+    - cron: "41 4 * * *"
+  workflow_dispatch:
+
+env:
+  # Short on a push or PR, long on the nightly schedule.
+  LONG: ${{ github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' }}
+
+jobs:
+  differential:
+    name: Randomized differential (vs Lexbor's engine)
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout (with vendored Lexbor submodule)
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Ensure cmake is available
+        uses: lukka/get-cmake@latest
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - name: Install libclang (bindgen, via rb-sys)
+        run: sudo apt-get update && sudo apt-get install -y libclang-dev
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      # build.rs links the vendored Lexbor archive and reads its headers.
+      - name: Compile the extension (builds Lexbor)
+        run: bundle exec rake compile
+
+      # Release: the sweep is the point, and debug is ~10x slower. The seed is
+      # fresh per run, so a long series covers new ground; it is printed here
+      # and in any failure, so a finding reproduces.
+      - name: Run the css_match tests with a fresh seed
+        working-directory: ext/makiri/rust
+        run: |
+          export MAKIRI_CSS_DIFF_SEED=$(printf '0x%x' $(( (GITHUB_RUN_ID * 2654435761 + GITHUB_RUN_ATTEMPT) & 0xffffffffffff )))
+          if [ "$LONG" = true ]; then
+            export MAKIRI_CSS_DIFF_ITERATIONS=1000000
+          else
+            export MAKIRI_CSS_DIFF_ITERATIONS=20000
+          fi
+          echo "MAKIRI_CSS_DIFF_SEED=$MAKIRI_CSS_DIFF_SEED MAKIRI_CSS_DIFF_ITERATIONS=$MAKIRI_CSS_DIFF_ITERATIONS"
+          cargo test --release --no-default-features --features lexbor -- \
+            lexbor::tests::css_match lexbor::tests::selector_cache
+
+  fuzz:
+    name: cargo-fuzz ${{ matrix.target }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [html_css, html_css_diff]
+    steps:
+      - name: Checkout (with vendored Lexbor submodule)
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - name: Ensure cmake is available
+        uses: lukka/get-cmake@latest
+
+      # -Zsanitizer is unstable, and cargo-fuzz needs it.
+      - uses: dtolnay/rust-toolchain@nightly
+
+      - name: Install libclang (bindgen, via rb-sys)
+        run: sudo apt-get update && sudo apt-get install -y libclang-dev
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      - name: Compile the extension (builds Lexbor)
+        run: bundle exec rake compile
+
+      - name: Install cargo-fuzz
+        run: cargo install cargo-fuzz --locked
+
+      - name: Build the fuzz target
+        working-directory: ext/makiri/rust/fuzz
+        run: cargo fuzz build ${{ matrix.target }}
+
+      # As in libfuzzer.yml: nm -u reads 0 on Linux whether or not the binary
+      # is instrumented, so assert on the full symbol table.
+      - name: Assert the target is instrumented
+        working-directory: ext/makiri/rust/fuzz
+        run: |
+          bin=$(ls target/*/release/${{ matrix.target }})
+          reports=$(nm "$bin" | grep -c '__asan_report')
+          echo "$bin: __asan_report symbols = $reports"
+          test "$reports" -gt 0 || { echo "not ASan-instrumented"; exit 1; }
+
+      # Both targets read the same `selector NUL document` input, so each
+      # also starts from the other's corpus (read-only: new units go to the
+      # first directory). The cache prefix is libfuzzer.yml's, so the corpus
+      # accumulated there carries over.
+      - name: Restore the corpus
+        uses: actions/cache@v6
+        with:
+          path: ext/makiri/rust/fuzz/corpus/${{ matrix.target }}
+          key: cargo-fuzz-corpus-${{ matrix.target }}-${{ github.run_id }}
+          restore-keys: |
+            cargo-fuzz-corpus-${{ matrix.target }}-
+
+      - name: Restore the sibling corpus
+        uses: actions/cache/restore@v6
+        with:
+          path: ext/makiri/rust/fuzz/corpus/${{ matrix.target == 'html_css' && 'html_css_diff' || 'html_css' }}
+          key: cargo-fuzz-corpus-${{ matrix.target == 'html_css' && 'html_css_diff' || 'html_css' }}-${{ github.run_id }}
+          restore-keys: |
+            cargo-fuzz-corpus-${{ matrix.target == 'html_css' && 'html_css_diff' || 'html_css' }}-
+
+      # -timeout: html_css_diff runs Lexbor's exhaustively backtracking engine
+      # too; the harness skips inputs it cannot afford, and this is the stop
+      # for one it misjudged.
+      - name: Run cargo-fuzz ${{ matrix.target }}
+        working-directory: ext/makiri/rust/fuzz
+        run: |
+          sibling=${{ matrix.target == 'html_css' && 'html_css_diff' || 'html_css' }}
+          mkdir -p corpus/${{ matrix.target }} corpus/$sibling
+          if [ "$LONG" = true ]; then seconds=3600; else seconds=180; fi
+          cargo fuzz run ${{ matrix.target }} corpus/${{ matrix.target }} corpus/$sibling -- \
+            -max_total_time=$seconds \
+            -max_len=4096 \
+            -timeout=30 \
+            -dict=css.dict \
+            -print_final_stats=1
+
+      - name: Upload reproducers
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: cargo-fuzz-artifacts-${{ matrix.target }}
+          path: ext/makiri/rust/fuzz/artifacts/${{ matrix.target }}
+          retention-days: 30

data/.github/workflows/libfuzzer.yml

@@ -25,7 +25,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        target: [xml, xpath, xml_xpath, css, html, html_xpath, html_css]
+        # html_css and html_css_diff run in css-match.yml, with the selector
+        # dictionary and a longer budget.
+        target: [xml, xpath, xml_xpath, css, html, html_xpath]
 
     steps:
       - name: Checkout (with vendored Lexbor submodule)

data/CHANGELOG.md

@@ -1,5 +1,78 @@
 # Changelog
 
+## [0.12.1] - 2026-10-02
+
+### Fixed
+
+* Passing a string literal from a file without
+  `# frozen_string_literal: true` no longer warns "literal string will be
+  frozen in the future" on Ruby 3.4+ (with deprecation warnings enabled).
+* A fragment parsed with a context element from another document
+  (`fragment(context:)`, `DocumentFragment.parse(context:)`) no longer keeps
+  a reference into that document, which could be read after that document was
+  freed.
+* The 10,000-option limit per `<select>` now also counts the options a
+  fragment parsed in a select context receives (`inner_html=` and
+  `outer_html=` on or inside a select, `fragment(context: "select")`).
+  Before, they went uncounted, and inserting them took time quadratic in
+  their number.
+* A String `context:` naming a node that is not an element (`"#text"`,
+  `"!--"`, ...) raises `ArgumentError`.
+
+### Security
+
+* Hardening against Lexbor edge cases in fragment parsing, node copying,
+  element creation and serialization. Serialization is now always Makiri's
+  own walk, which uses no native recursion, so `to_html` / `inner_html` are
+  about 3% slower.
+
+## [0.12.0] - 2026-10-01
+
+Most changes accept what the DOM allows where 0.11.0 raised. The XML
+serializers (`to_xml`, `canonicalize`) raise instead when the tree holds
+something XML cannot write.
+
+### Changed
+
+HTML:
+
+* `to_html` / `inner_html` write a `<template>`'s contents, not its own
+  children (added with `add_child`), as browsers do.
+* `create_element_ns` in the HTML namespace accepts an upper-case name
+  (`BR`, `DIV`), as the DOM does. It makes an unknown element: not void, and
+  not matched by type selectors. Importing such an XHTML element from XML
+  behaves the same way.
+
+XML:
+
+* Text, attribute values and comments accept the characters the DOM allows:
+  `"\f"`, U+0001, NUL, and `--` in a comment.
+* `set_attribute_ns` accepts names XML cannot write, such as `p:a}b`.
+* `to_xml` and `canonicalize` raise while any of the above is in the tree.
+* `create_cdata` with `]]>` and `create_processing_instruction` with `?>`
+  now raise `ArgumentError`.
+* `canonicalize` adds the namespace declarations a name needs instead of
+  raising. It still raises where it would have to invent a prefix.
+
+HTML to XML (`import_node`):
+
+* The copy is in its namespace at once. Before, it was in none until
+  inserted.
+* The copy gets no `xmlns` attribute.
+* An attribute XML cannot write (`x-on:click`, `@click`) is copied as it is
+  instead of raising.
+* A `<template>` keeps its own children, after its contents.
+
+Other:
+
+* `Node#path` round-trips when a sibling with a different prefix or case
+  would also match the same XPath step.
+
+## [0.11.0] - 2026-09-30
+
+No code changes since 0.11.0.rc2. Coming from 0.10.x, read the rc2 and rc1
+notes below as well.
+
 ## [0.11.0.rc2] - 2026-09-30
 
 ### Added

data/NOKOGIRI_DIFFERENCES.md

@@ -184,11 +184,11 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
     that does not fit the name (`set_attribute_ns`, `create_element_ns`)
     raises `Makiri::Error`. Invalid UTF-8 raises `Makiri::Error` for every
     argument, names included.
-  * `create_element_ns` refuses an HTML-namespace name in upper case that
-    lower-cases to an element Lexbor knows (`BR`, `DIV`), where the DOM makes
-    an unknown element: Lexbor would make that element (`BR` void, its
-    children never written). Other names keep their case (`MY-EL`). Nokogiri
-    has no `create_element_ns`.
+  * `create_element_ns` keeps the case of an HTML-namespace name, as the DOM
+    does: `create_element_ns(XHTML, "BR")` is an unknown element named `BR`,
+    not a void `br`, and type selectors do not match it (XPath name tests do,
+    folding case on HTML elements as browsers do). Nokogiri has no
+    `create_element_ns`.
 * An HTML `<template>` follows the WHATWG content model, which Nokogiri does
   not: its parsed contents live in the separate fragment `Element#content_fragment`
   returns, `template.children` is empty, and `inner_html` / `inner_html=`
@@ -198,6 +198,11 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   ordinary element, with the parsed nodes as its children, so
   `template.inner_html` and `template.children` answer the other way round and
   there is no `content_fragment`.
+  * `Makiri::XML` has no template contents: an XHTML `<template>`'s children
+    are its children. Crossing into HTML they become its contents, and back
+    they become children - what a browser's XML parser, which puts them in the
+    contents, and its importNode give for the same document. An XML
+    `<template>` whose children should stay children has no way to say so.
 * An HTML document has one root element and no text child, as the DOM requires;
   `doc << element` beside an existing root raises.
 * An insertion the DOM refuses - a child under a text, comment, PI, doctype
@@ -205,13 +210,20 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   `Makiri::Error` in both representations. Nokogiri refuses the same ones with
   `ArgumentError` (or `RuntimeError` for a second XML root).
 * Moving HTML into an XML document (`xml_doc.import_node(html_node)`, or
-  inserting one) keeps every name's namespace, and refuses what XML cannot
-  write that way. An attribute in no namespace whose name has a prefix other
-  than `xml` - `v-on:click`, `fb:like`, an `xlink:href` on an HTML (not SVG)
-  element - raises `Makiri::Error`: as XML it would be a prefix bound to
-  nothing. Nokogiri copies it and writes `v-on:click="..."` into output that is
-  not namespace-well-formed. An element named with a colon (`<fb:like>`)
-  crosses as a DOM-loose name, which `to_xml` refuses.
+  inserting one) copies it as the DOM's clone does: every element in its
+  namespace from the start (an imported `<p>` is XHTML before it is
+  inserted), every attribute named as it is, and no `xmlns` attribute added -
+  `to_xml` and `canonicalize` write the declarations the output needs.
+  Nokogiri's copy of an HTML5 `<div>` is in no namespace, and libxml2
+  declares `xmlns:svg` on it for an SVG child (in `namespace_definitions`),
+  writing the child as `<svg:svg>`. One XML cannot write that way -
+  in no namespace with a colon or no XML name, `v-on:click`, `:href`,
+  `@click`, `fb:like` - crosses DOM-loose, and `to_xml` refuses the tree
+  while it is there; so does an element named with a colon (`<fb:like>`).
+  Nokogiri copies them and writes output that is not namespace-well-formed.
+  * 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
@@ -284,7 +296,7 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   case-sensitivity rule, as browsers do: lower-cased for an HTML element (`LI`
   matches `<li>`), as written for any other (`feGaussianBlur` matches the SVG
   element, `fegaussianblur` does not). An HTML element named in upper case
-  (`create_element_ns(XHTML, "MY-EL")`, which keeps its name as the DOM does)
+  (`create_element_ns(XHTML, "DIV")`, which keeps its name as the DOM does)
   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
@@ -321,5 +333,12 @@ what browsers do - rather than libxml2. Detailed, test-backed notes live in
   `Makiri::Error`.
   * On re-parse, the HTML tokenizer replaces a U+0000 in text/attributes with
     U+FFFD (WHATWG), so a serialized-then-reparsed round-trip is not byte-identical.
-  * `Makiri::XML` rejects NUL everywhere: XML 1.0 has no legal U+0000 character,
-    so admitting it would produce non-well-formed XML.
+  * `Makiri::XML` holds the character data the DOM holds, NUL included:
+    text or an attribute value with a character XML has no `Char` for (`\f`,
+    U+0001, U+0000), a comment with `--`. Nokogiri takes the same, but NUL
+    (`ArgumentError`, a Ruby C-string limit). Where they part is the output. `to_xml` / `canonicalize` raise for such a tree; Nokogiri writes
+    `\f` in text as U+FFFD (the data changes) and a comment's `--` or an
+    attribute value's `\f` as it stands (the output does not parse).
+    `create_cdata` refuses `]]>` and `create_processing_instruction` `?>`,
+    raising `ArgumentError` as the DOM's factories do; Nokogiri takes the PI
+    and writes `<?t a?>b?>`, which re-reads as another tree.

data/Rakefile

@@ -857,7 +857,9 @@ namespace :fuzz do
   # library and headers (the crate's build.rs links the archive and generates
   # the layout from the headers), which `rake compile` produces - hence the
   # dependency, which is about Lexbor rather than about the bundle.
-  FUZZ_TARGETS = %w[xml xpath xml_xpath css html html_xpath html_css].freeze
+  FUZZ_TARGETS = %w[xml xpath xml_xpath css html html_xpath html_css html_css_diff].freeze
+  # The targets whose input starts with a CSS selector take its dictionary.
+  FUZZ_CSS_DICT = %w[html_css html_css_diff].freeze
 
   # The local mode: TARGETS=css,html_xpath narrows the run to what you touched,
   # and the time is FUZZ_TIME seconds per target (default 60) or FUZZ_BUDGET
@@ -916,8 +918,9 @@ namespace :fuzz do
     env, sanitizer = libfuzzer_invocation
     Dir.chdir("ext/makiri/rust/fuzz") do
       targets.each do |target|
+        dict = FUZZ_CSS_DICT.include?(target) ? ["-dict=css.dict"] : []
         sh env, "cargo", "fuzz", "run", *sanitizer, target, "--",
-           "-max_total_time=#{time}", "-max_len=4096"
+           "-max_total_time=#{time}", "-max_len=4096", *dict
       end
     end
   end

data/lib/makiri/element.rb

@@ -22,5 +22,21 @@ module Makiri
     def path_step
       name_step("", unprefixed_element_namespace)
     end
+
+    # See {NodePath#path}. An element step selects by expanded name, not by the
+    # string of the test: `*[local-name()='BR' and ...]`, written for `h:BR`,
+    # also selects the unprefixed `BR` beside it. A bare name test on an HTML
+    # element folds ASCII case, as the engine (and browsers) match it, so `div`
+    # also selects the `DIV` createElementNS makes. Compared as strings, each
+    # pair was counted apart, and the path found the other one first.
+    def path_selects?(other, test)
+      return false unless other.element? && other.namespace_uri.to_s == namespace_uri.to_s
+
+      mine = local_name
+      theirs = other.local_name
+      return mine == theirs unless test == name && unprefixed_element_namespace
+
+      mine.downcase(:ascii) == theirs.downcase(:ascii)
+    end
   end
 end

data/lib/makiri/node_path.rb

@@ -48,7 +48,7 @@ module Makiri
       parent_node = parent
       return test unless parent_node # a detached top: #path answers "?" anyway
 
-      siblings = parent_node.children.select { |c| c.path_node_test == test }
+      siblings = parent_node.children.select { |c| path_selects?(c, test) }
       return test if siblings.length <= 1
 
       "#{test}[#{siblings.index(self) + 1}]"
@@ -73,6 +73,13 @@ module Makiri
       nil
     end
 
+    # Whether +test+, this node's own step, selects +other+, a sibling: the
+    # position counts exactly those. By default the tests are compared, which
+    # is the engine's answer for every kind but an element (see Element).
+    def path_selects?(other, test)
+      other.path_node_test == test
+    end
+
     # The name test for an element (+axis+ "") or attribute (+axis+ "@"): the
     # bare name when an unprefixed test reaches this node - it is in
     # +plain_namespace+ and its name is a plain NCName - else by expanded name.

data/lib/makiri/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Makiri
-  VERSION = "0.11.0.rc2"
+  VERSION = "0.12.1"
 end

data/script/check_unsafe_boundaries.rb

@@ -31,14 +31,14 @@ RUST = File.join(ROOT, "ext/makiri/rust/src")
 UNSAFE_ISLANDS = {
   "bridge/alloc.rs" => 4,
   "bridge/doc.rs" => 3,
-  "bridge/fragment.rs" => 5,
+  "bridge/fragment.rs" => 6,
   "bridge/gvl.rs" => 5,
   "bridge/html.rs" => 17,
   "bridge/node_set.rs" => 8,
   "bridge/node_wrap.rs" => 1,
   "bridge/ruby.rs" => 18,
   "bridge/stack.rs" => 1,
-  "bridge/string.rs" => 28,
+  "bridge/string.rs" => 29,
   "bridge/typed.rs" => 21,
   "bridge/wrapper.rs" => 19,
   "bridge/xml.rs" => 11,
@@ -56,13 +56,14 @@ UNSAFE_ISLANDS = {
   "lexbor/adapter/arena_bytes.rs" => 14,
   "lexbor/adapter/cross_import.rs" => 2,
   "lexbor/adapter/html/attrs.rs" => 20,
-  "lexbor/adapter/html/build.rs" => 18,
-  "lexbor/adapter/html/mod.rs" => 60,
+  "lexbor/adapter/html/build.rs" => 24,
+  "lexbor/adapter/html/mod.rs" => 62,
   "lexbor/adapter/html/mutate.rs" => 9,
+  "lexbor/adapter/html/serialize.rs" => 18,
   "lexbor/adapter/post_parse.rs" => 13,
   "lexbor/adapter/source_loc.rs" => 2,
   "lexbor/adapter/text_index.rs" => 1,
-  "lexbor/adapter/tree_guard.rs" => 8,
+  "lexbor/adapter/tree_guard.rs" => 9,
   "lexbor/chunks.rs" => 2,
   "lexbor/css_engine.rs" => 14,
   "lexbor/css_parser.rs" => 21,
@@ -73,7 +74,7 @@ UNSAFE_ISLANDS = {
   "lexbor/selectors.rs" => 9,
   "lexbor/serialize.rs" => 2,
   "lexbor/stylesheet.rs" => 7,
-  "lexbor/tests.rs" => 14,
+  "lexbor/tests.rs" => 16,
   "lexbor/xpath.rs" => 9,
   "token.rs" => 1,
 }.freeze
@@ -461,7 +462,7 @@ end
 # is generated, so its signature is Lexbor's. A new hand declaration of a
 # header-declared function belongs in build.rs's allowlist instead; one with no
 # header belongs in build.rs's UNDECLARED_EXPORTS as well as here.
-LEXBOR_HAND_DECLS = 3
+LEXBOR_HAND_DECLS = 5
 abi_decls = comments_removed(File.binread(File.join(RUST, "lexbor/abi.rs"))).scan(LEXBOR_DECL).length
 if abi_decls != LEXBOR_HAND_DECLS
   errors << "lexbor/abi.rs hand-declares #{abi_decls} Lexbor functions (expected " \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: makiri
 version: !ruby/object:Gem::Version
-  version: 0.11.0.rc2
+  version: 0.12.1
 platform: aarch64-linux
 authors:
 - takahashim
@@ -64,6 +64,7 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
 - ".github/workflows/conformance.yml"
+- ".github/workflows/css-match.yml"
 - ".github/workflows/libfuzzer.yml"
 - ".github/workflows/release.yml"
 - ".github/workflows/security.yml"