latexmath 0.1.4 → 1.0.0

data/docs/model-contract.adoc

@@ -0,0 +1,125 @@
+= LaTeX model contract
+:toc:
+
+== Scope
+
+`Latexmath.parse(input, decimal: ".", engine: :auto)` returns a
+`Latexmath::Model::Document`. This document says how that model is derived
+from the grammar, how it is built, and how it is checked. The syntax side,
+including preprocessing, errors and the legacy raw tree, is in
+link:parser-contract.adoc[the parser contract].
+
+== Shape normalization of the grammar
+
+Under Parslet's flattening rules one capture name of the legacy grammar can
+hold text, a hash, a list or nil, depending on which alternative matched. A
+typed model needs one type per field. So `scripts/generate_grammar.rb` first
+rewrites the exported grammar so that every capture holds one kind of value,
+and then emits `grammars/latex.parg`. The rewrite only adds captures or spells
+a construct in an equivalent way, so the grammar accepts exactly the same
+inputs.
+
+The rules N1 to N7 come from `scripts/normalize_shapes.rb`, shared with the
+other stage gems. LaTeX needs four more, applied before them:
+
+[cols="1,4"]
+|===
+|Rule |Rewrite
+
+|N8 catalog text
+|The text of a `symbols` or `unicode_symbols` capture, which the legacy
+transform looks up in the symbol table, is captured as `spelling`. The model
+holds a `MathSymbol` there.
+
+|N9 empty list
+|A capture of text that the legacy grammar writes as an empty list when
+nothing matched (`(*x) as c`, also through a rule) holds an empty string
+instead: `*x` is written `*x &*x`. Its text is captured as `text_list` (or is
+the `spelling` of N8).
+
+|N10 list site
+|A capture that holds a hash at some places and a list at others is captured
+as `items` where it holds a list.
+
+|N11 named option
+|`[x] as c`, which is nil when `x` is absent, is written
+`(x / "" as absent) as c`.
+|===
+
+Generation stops if any capture is still multi-kind or can hold nil. It also
+stops if a rule that is shared by every decimal marker would normalize
+differently under one of them.
+
+`grammars/latex.wrappers.json` lists every added capture with how it unwraps:
+
+[cols="1,1,3"]
+|===
+|Capture |Kind |Legacy value
+
+|`literal`, `literal_<n>` |text |the wrapped text
+|`spelling`, `text_list` |text_list |the text, or `[]` when it is empty
+|`items` |items |the list
+|`absent` |nil |nil
+|===
+
+`Latexmath::Unwrap` replaces each added capture by that value and folds the
+parts with Parsanol's own `merge_fold` and `flatten_repetition`, so it gives
+back the legacy tree exactly. It serves the raw-tree boundary and parity
+replay only.
+
+`grammars/latex.normalized-rules.json` holds the normalized rules of the
+`dot` entry, from which the model classes are generated.
+
+== Model classes
+
+`scripts/generate_model.rb` writes `lib/latexmath/model/nodes.rb` from the
+capture shapes of the normalized rules:
+
+* a capture that holds a hash becomes a class named after it, with one
+  attribute per key;
+* a capture that holds a list becomes a class `<Capture>Item` for its
+  elements, and the attribute is a collection of it;
+* a capture that holds text is a `:string` attribute;
+* a capture whose only key is `spelling` is a `MathSymbol`.
+
+An attribute has the same name and type wherever it occurs. The matrix row
+break, which the legacy tree keys as `"\\"`, is the attribute `row_break`.
+The classes are plain LutaML Model classes: no union types, no cast hooks.
+`Document` has `expression`, the formula's tree, and `decimal`, the decimal
+marker the input was parsed with. Numbers keep their digits and marker as
+written.
+
+`MathSymbol` has the attribute `spelling`, the text the grammar matched. Its
+`value` (Unicode text) and `kind` (`symbol`, `open` or `close`) are read from
+`data/latex-symbols.json` for the spelling, stripped, as in the legacy
+transform. A spelling the table lacks stands for itself, kind `symbol`.
+
+== Construction
+
+Each grammar entry declares two bindings on the tree capture:
+
+----
+latex_tree -> latex_tree (raw)
+latex_tree -> model (any)
+----
+
+The raw binding gives the tree with slices and offsets. The model binding
+gives the same tree as plain data, and `Document.new(expression: ...)` builds
+the whole typed tree from the declared attribute types. No code walks the
+parse tree.
+
+Input with no formula (empty, or only spaces and newlines, which the
+preprocessing removes) returns a `Document` whose `expression` is nil.
+
+== Checks
+
+* `ruby scripts/generate_grammar.rb --check` and
+  `ruby scripts/generate_model.rb --check` require the committed grammar,
+  wrappers, normalized rules and model classes to equal a fresh generation.
+* `bundle exec ruby scripts/verify_lml.rb` exports every model class with
+  `Lutaml::Model::Lml.export`, requires the result to equal
+  `model/latex.lml.json` and its checksums, and verifies every document.
+* The parity replay (`spec/parser/oracle_parity_spec.rb`) requires, for every
+  parsed row and on both engines, that the unwrapped tree equals the legacy
+  tree, that the model as data equals the bound data, and that the unwrapped
+  model gives the legacy tree's text.

data/docs/parser-contract.adoc

@@ -0,0 +1,349 @@
+= LaTeX parser contract (syntax)
+:toc:
+
+== Status and scope
+
+This document fixes the LaTeX syntax boundary that the latexmath stage gem
+must reproduce, and the way the legacy behaviour is captured as evidence. It
+covers input preprocessing, the raw grammar tree, decimal markers and errors.
+
+It does not define the typed language model. The gem's one public entry point
+is `Latexmath.parse(input, ...)`, and it returns the typed LaTeX model. The
+fields, types and class names of that model are defined in
+link:model-contract.adoc[the model contract]. The raw grammar tree described here is an internal and test
+boundary. It is not public API.
+
+The shared stage profile is amath
+https://github.com/plurimath/amath/blob/main/docs/stage-contract.adoc[`docs/stage-contract.adoc`].
+It defines the common shape of the stage gems: one public `parse`, the error
+classes and their offsets, artifacts and replay. This document keeps the rules
+that are specific to LaTeX.
+
+== Implementation in this gem
+
+The raw-tree boundary already exists in this gem:
+
+* `grammars/latex.parg`, generated by `scripts/generate_grammar.rb` from the
+  pinned Plurimath grammar, and its compiled parse artifact
+  `artifacts/latex.json` with one bindings artifact per Parsanol target,
+  `artifacts/latex.bindings.<target>.json`. `scripts/compile.rb` builds them
+  with `parsanol parg compile --bindings all` (Parsanol 1.3.131 or later),
+  verifies and pairs every bindings artifact, and with `--determinism`
+  requires a second compilation to give the same bytes;
+* `Latexmath::Preprocessor`, the legacy preprocessing described below;
+* `Latexmath::RawParser`, which runs preprocessing, the grammar and the
+  declared bindings on the Ruby or the native Parsanol engine, and returns
+  the preprocessed text and the legacy raw tree. It is internal;
+* `data/latex-symbols.json`, the legacy symbol table, and
+  `Latexmath::Symbols`, which reads it (see <<Symbols>>).
+
+`Latexmath::ParseError` carries the offsets described under <<Errors>>.
+
+== Reference implementation
+
+The behaviour to reproduce is the LaTeX path of Plurimath at one fixed commit.
+`scripts/oracle/pins.yml` records it:
+
+* Plurimath `e7ab4a5186c9be96f62d670574bc2c72f9365ad4`
+* plurimath-testsuite `281059b213026a54a193cb020a5816f57cabf3a8`, the source
+  of the fixture rows the full replay captures (see <<Replay>>)
+
+The legacy LaTeX path at that commit consists of these files:
+
+[cols="3,1,1,4"]
+|===
+|File |Bytes |Rules |Role
+
+|`lib/plurimath/latex.rb`
+|459
+|0
+|Entry class. `to_formula` runs the parser.
+
+|`lib/plurimath/latex/parser.rb`
+|1033
+|0
+|Preprocessing, then grammar, then transform.
+
+|`lib/plurimath/latex/parse.rb`
+|11744
+|35
+|Parsanol grammar. It also builds rules from symbol and constant tables at
+run time.
+
+|`lib/plurimath/base_number_prefix.rb`
+|1622
+|6
+|Hexadecimal, binary and octal number rules shared with other languages.
+
+|`lib/plurimath/latex/constants.rb`
+|5301
+|0
+|Tables the grammar reads: environments, parentheses, operators.
+
+|`lib/plurimath/latex/utility.rb`
+|4359
+|0
+|Helpers, including HTML entity encoding of the decimal marker.
+
+|`lib/plurimath/latex/transform.rb`
+|29673
+|116
+|Turns the raw tree into Plurimath formula objects.
+|===
+
+Rule counts are the number of `rule(` lines in each file. `pins.yml` also
+records the SHA-256 of each file. The grammar is data-driven: many of its
+alternatives come from Plurimath symbol tables, so a stage grammar must be
+generated from the pinned commit rather than written by hand.
+
+== Input preprocessing
+
+The public entry point owns preprocessing. The legacy steps, in order, are:
+
+. Remember every `\mbox{...}` and `\text{...}` group in the original input.
+. Decode HTML entities, then encode the whole text again with hexadecimal
+  entities. Every non-ASCII character, every newline and the characters
+  `<`, `>`, `&`, `"` and `'` become `&#x...;`.
+. Remove every space that does not follow a backslash, and every run of raw
+  newlines.
+. Replace a row break followed by a space (`\\ `) with a plain row break `\\`.
+. Turn `&#x26;` back into `&` and `&#x22;` back into `"`. The other entities
+  stay encoded.
+. Turn a backslash followed by an encoded newline (`\&#xa;`) into an escaped
+  space `\ `, unless that backslash ends a row break. Remove the remaining
+  `&#xa;`.
+. Put the remembered `\mbox` and `\text` groups back exactly as the caller
+  wrote them, including spaces and non-ASCII characters.
+
+For example, `a < b \\ c` followed by a newline and `\text{é x} é` becomes
+`a&#x3c;b\\c\text{é x}&#xe9;`.
+
+The grammar parses this preprocessed text, not the caller's input. Slice
+offsets in the raw tree point into the preprocessed text. Outside restored
+`\mbox` and `\text` groups the preprocessed text is ASCII.
+
+== Raw grammar tree
+
+The raw tree is what `Plurimath::Latex::Parse#parse` returns for the
+preprocessed text. It is made of hashes, arrays and slices:
+
+* A hash maps capture names to values. Capture names are symbols. Insertion
+  order is part of the tree.
+* An array keeps repeated captures in input order.
+* A slice is matched text with its offset in the preprocessed text. Parsanol
+  counts that offset (`Slice#offset`) in bytes, on both engines. The capture
+  records it as the byte offset and also records the character offset it
+  falls at. The two differ only after non-ASCII text inside a restored
+  `\mbox` or `\text` group. A stage gem that reports positions in the
+  caller's text must map offsets back explicitly.
+
+One key is special. The grammar captures a matrix row break as the symbol
+`:"\\\\"`, and `Parse#parse` then renames that key to the string `"\\\\"`.
+This string key is part of the tree. A grammar format that cannot spell the
+key must emit another name and rename it back.
+
+The grammar in this gem adds captures so that every capture holds one kind
+of value (see link:model-contract.adoc[the model contract]). The tree it
+produces is therefore not the legacy tree itself. `Latexmath::Unwrap` removes
+the added captures, using `grammars/latex.wrappers.json`, and gives the
+legacy tree back; `Latexmath::RawParser` returns both. Parity is checked on
+the unwrapped tree.
+
+== Decimal marker and locale
+
+The caller chooses a locale with the `locale:` option. The locale selects the
+decimal marker: `.` by default, `,` for locales such as `fr`, and the Arabic
+decimal separator `٫` (U+066B) for `ar`. The grammar matches the marker in its encoded
+form, because preprocessing has already turned non-ASCII characters into
+hexadecimal entities.
+
+The legacy grammar caches generated rules in class variables. After the first
+parse in a process, those rules keep the decimal marker of that first parse.
+The stage gem must instead behave like a fresh process for every call: one
+call, one marker, no state carried between calls. For the same reason the
+capture harness runs every row in a new process.
+
+== Errors
+
+A refusal is an input the legacy path does not accept. It is data, not a
+failure of the capture. A refusal happens at one of three stages:
+
+preprocess:: preprocessing raised an error.
+grammar:: the grammar did not match the preprocessed text.
+transform:: the grammar matched, but the transform could not build a formula.
+
+For grammar refusals the error position is part of the contract: the byte
+offset in the preprocessed text where matching failed (Parsanol's
+`Cause#pos`, which counts bytes), and the character offset it falls at. The
+class of the error is recorded. The wording of grammar messages is not part
+of the contract; the capture keeps only its first line and a SHA-256 of the
+full message.
+
+`Latexmath::ParseError` reports the position in the caller's text, as the
+stage contract requires: `input` is the caller's input as normalized UTF-8,
+and `byte_offset` and `char_offset` count UTF-8 bytes and characters in it.
+`Latexmath::SourceMap` maps the grammar position back through the
+preprocessing. It runs the preprocessing steps again, recording for every
+character written the caller character it came from, and maps only when it
+writes exactly the bytes the preprocessing wrote (otherwise the offsets are
+nil). A character the preprocessing wrote in place of other text (an encoded
+or decoded entity, the escaped space for a backslash before a newline) maps
+to the start of that text; a restored `\text` or `\mbox` group maps
+character for character; removed spaces and newlines leave nothing behind,
+so a position after them maps to the caller character that follows.
+
+The grammar's own position stays on the error for replay and diagnostics:
+`grammar_input` is the preprocessed text and `grammar_byte_offset` and
+`grammar_char_offset` are the recorded position in it. Raw replay compares
+those with the capture, and checks that the public position lies in the
+caller's text. `NestingTooDeep` sets both inputs and leaves every offset
+nil.
+
+The mapping does not change the preprocessed text itself: the raw boundary
+still returns it as the legacy preprocessing does, in US-ASCII when nothing
+outside a restored group is non-ASCII.
+
+== Symbols
+
+The legacy transform turns the text of a `:symbols` or `:unicode_symbols`
+capture, stripped, into a Plurimath symbol:
+`Plurimath::Utility.all_symbols_classes(:latex)[text]&.new`, or a plain
+`Plurimath::Math::Symbols::Symbol` of that text when the table lacks it.
+
+`scripts/export_symbols.rb` writes that table from the pinned Plurimath into
+`data/latex-symbols.json`, so the gem resolves symbols without Plurimath. It
+runs in the oracle bundle (see <<Oracle environment>>):
+
+[source,sh]
+----
+BUNDLE_GEMFILE=<oracle>/.latexmath-oracle/Gemfile \
+  bundle exec ruby scripts/export_symbols.rb --oracle <oracle> [--check]
+----
+
+The file records the oracle repository, commit, `lib` tree and oracle lock,
+counts, and one record per spelling, sorted by spelling:
+
+`spelling`:: the captured text the table keys: a command name without its
+backslash (`alpha`), a hexadecimal entity (`&#x3b1;`) or another spelling
+Plurimath lists for LaTeX;
+`value`:: the Unicode text of the MathML the legacy class writes;
+`mathml`:: that MathML element, `mi` or `mo`;
+`kind`:: `symbol`, or `open`, `close` or `paren` for a Plurimath paren;
+`class`:: the legacy class, relative to `Plurimath::Math::Symbols`, for the
+facade mapper.
+
+At the pinned commit the table has 3,280 spellings of 1,421 classes: 3,218
+symbols, 41 opening and 21 closing parens. `Latexmath::Symbols.lookup` gives
+the record for a captured text, or nil; `Latexmath::Symbols.resolve` gives a
+plain symbol of the text instead of nil, as the legacy transform does. The
+CI parity job runs the export with `--check` against the pinned checkout.
+
+== Capture of legacy behaviour
+
+`scripts/oracle/capture.rb` records the legacy behaviour row by row. Each row
+names an input and its configuration. For each row it records four
+boundaries:
+
+. the caller's input and options;
+. the preprocessed text;
+. the raw grammar tree, or the grammar error;
+. the facade outcome of `Plurimath::Math.parse`: the formula objects and the
+  output of every writer (AsciiMath, LaTeX, MathML, OMML, HTML, UnicodeMath),
+  or the refusal.
+
+The formula objects are recorded by class and instance variables. That record
+is the baseline to compare against later. It does not define the stage model.
+
+=== Canonical tagged form
+
+Every captured value is written in a tagged form that keeps the differences
+the comparison needs: hash versus array, symbol versus string, key order, nil
+versus a missing key, empty string versus empty list, object class, slice text
+and offsets. Numbers keep their spelling and are never converted to floats.
+Text that is not valid UTF-8 is kept as hexadecimal bytes. Nothing is sorted.
+
+A slice is written as `{"t": "slice", "v": text, "byte_offset": n,
+"char_offset": m}`. `byte_offset` is Parsanol's offset as it is;
+`char_offset` is the number of characters in the first `byte_offset` bytes of
+the preprocessed text, read as UTF-8. A recorded error has `byte_offset` and
+`char_offset` in the same sense. An error message's first line is a plain
+string when it is valid UTF-8. A message that quotes text which is not valid
+UTF-8 keeps its first line, cut to 160 bytes, in the tagged bytes form
+`{"t": "bytes", "hex": ..., "enc": ...}`, and the SHA-256 covers its bytes.
+
+Raw trees and formulas of nested input go deeper than the JSON library's
+default nesting limit of 100. The worker, the checkpoint and the report write
+and read JSON without that limit.
+
+=== Row outcomes
+
+Every row ends in exactly one of four states:
+
+succeeded:: the child exited with status 0 and replied with a capture.
+refused:: the child exited with status 0 and replied with a refusal.
+timed_out:: the child was still running when the deadline passed.
+crashed:: the child exited with a non-zero status, died from a signal, or
+  wrote a reply that is not a valid capture.
+
+A timeout or crash is an incomplete capture, never a refusal. The deadline is
+measured on a monotonic clock. The end of the child's output is not the end
+of the child: the harness keeps waiting for the process to exit, and only a
+passed deadline with a live process counts as a timeout. A timed-out child and
+its process group are stopped.
+
+=== Inventory, report and resume
+
+Rows come from an inventory file such as `corpora/oracle/smoke.yaml`. Row
+identifiers must be unique. The report lists the selected identifiers and the
+count of rows in each state, and it is complete only when every selected row
+succeeded or was refused, with no missing or duplicate rows. The capture exits
+with status 0 only for a complete report.
+
+With `--checkpoint`, every finished row is appended to a JSON Lines file and
+flushed to disk before the next row starts. A later run with the same oracle,
+lock, worker, inventory and selection skips rows that succeeded or were
+refused, and runs timed-out and crashed rows again. A checkpoint from a
+different capture is rejected. A partly written last line is dropped.
+
+=== Oracle environment
+
+The oracle is a clean checkout of the pinned Plurimath commit.
+`scripts/oracle/setup.rb` installs its dependencies from the committed
+`scripts/oracle/oracle.gemfile.lock` into a bundle inside that checkout, kept
+apart from the latexmath bundle. The capture refuses to run when the checkout
+is at another commit, has local changes, or has a different lock. The report
+records the commit, the lock checksum and the worker checksum, and every row
+records the Ruby, Plurimath and Parsanol versions that produced it.
+
+The CI job `oracle-smoke` runs the harness smoke capture against the pinned
+checkout and keeps the report as a build artifact:
+
+[source,sh]
+----
+ruby scripts/oracle/setup.rb --oracle "$ORACLE_CHECKOUT"
+bundle exec ruby scripts/oracle/capture.rb --oracle "$ORACLE_CHECKOUT" \
+  --ids smoke-success,smoke-refusal --report smoke.json
+----
+
+[[Replay]]
+=== Full replay
+
+The `replay` workflow (`.github/workflows/replay.yml`) captures the legacy
+oracle for every LaTeX case of the pinned testsuite's
+`fixtures/parser-expectations.yaml`, in shards, and for the authored rows of
+`spec/parser/fixtures/oracle-sample.yaml` and `corpora/oracle/smoke.yaml`.
+It replays each capture through `spec/parser/oracle_parity_spec.rb` on the
+Ruby and the native engine. It runs on pull requests that change the grammar,
+the artifacts, the parser, the harness or the parity spec, every week and on
+demand. Every shard keeps its inventory, report, checkpoint and capture log as
+a build artifact. A mismatch is a parity finding to fix in the grammar,
+preprocessing or runtime; tolerances, row selection and expected data are not
+changed to make it pass.
+
+== Open points for the model contract
+
+The model contract settles which raw tree constructs become which typed model
+fields. These remain open:
+
+* how preprocessing source maps are exposed on the model, if at all;
+* how the selected engine is reported on the model.

data/docs/testsuite-pin.adoc

@@ -0,0 +1,76 @@
+= The plurimath-testsuite pin
+
+The LaTeX stage corpus lives in
+https://github.com/plurimath/plurimath-testsuite[plurimath-testsuite], in
+immutable numbered generations under `stages/latex/generations/`. Each
+generation is listed, with the digest of its files, in the append-only ledger
+`generations/latex.yaml`. This gem replays exactly one of those generations,
+named in `spec/fixtures/testsuite-pin.yml`:
+
+[source,yaml]
+----
+schema: plurimath-stage/pin/1
+repository: https://github.com/plurimath/plurimath-testsuite
+commit: fac69501e826d6bc140ca02e37bd70333cefd988
+language: latex
+generation: 2
+snapshot_digest: sha256:bad80c8a703e0761e96434779ff3826506be3702025b1bd77eb4c0e74bc58dde
+----
+
+Generation 2 keeps every case of generation 1 (the legacy corpus, produced by
+Plurimath 0.11.12) byte for byte and adds a raw-tree row for each of its 139
+cases, rejections included, written by `scripts/stage_cases.rb`.
+
+== What CI checks
+
+The `corpus` workflow checks out the testsuite at the pinned commit and then:
+
+. runs the testsuite's own validator,
+  `ruby scripts/validate-stages.rb <checkout> --pin spec/fixtures/testsuite-pin.yml`,
+  which checks that the checkout is at the pinned commit, that the ledger has
+  the pinned generation with the pinned digest, and that the generation's
+  files hash to that digest;
+. runs the same validator on copies of the pin with a wrong commit, a wrong
+  digest and a wrong generation, and fails if any of them is accepted;
+. runs `spec/corpus`, which makes the same checks in
+  `scripts/replay_corpus.rb` fail on a small generated testsuite;
+. runs `scripts/replay_corpus.rb`, which repeats the pin checks and then
+  parses every row of every raw-tree payload of the generation with
+  `Latexmath::RawParser.parse` on the Ruby and the native engine. Each
+  engine's result, the preprocessed text and tree or the refusal and its byte
+  offset, must equal the row's expected value in the canonical form of the
+  testsuite's `docs/tree-parity-contract.adoc`.
+
+To run the replay locally:
+
+[source,sh]
+----
+git clone https://github.com/plurimath/plurimath-testsuite tmp/testsuite
+git -C tmp/testsuite checkout fac69501e826d6bc140ca02e37bd70333cefd988
+bundle exec ruby scripts/replay_corpus.rb --testsuite tmp/testsuite --report tmp/replay.json
+----
+
+The `replay` and `stage-cases` workflows check out the testsuite at the same
+commit and fail if their commit and the pin's differ.
+
+== Parity with the legacy parser
+
+The pinned generation's raw-tree rows were generated from the generation 1
+inputs, so replaying them checks the current grammar against the trees this
+gem produced when they were written. The comparison with the legacy parser
+itself is made by the `replay` workflow: it captures the parse tree of the
+pinned Plurimath (`scripts/oracle/pins.yml`) for every LaTeX case of the
+testsuite's `fixtures/parser-expectations.yaml` and for the rows authored in
+this repository, and requires the raw tree and the typed model built by
+`Latexmath.parse` to match it on both engines. The legacy corpus itself is
+not changed by this gem: generation 1 stays as it was imported.
+
+== Moving the pin
+
+Commit, generation and digest change together, in one change, and only to a
+generation that is already merged in the testsuite. Take the values from the
+ledger entry, update `TESTSUITE_COMMIT` in the `corpus`, `replay` and
+`stage-cases` workflows to the same commit, and let CI replay the new
+generation. A generation whose rows this gem no longer reproduces is a
+regression to fix here, or a reason for a new generation in the testsuite;
+the pin never points at a generation the gem does not match.

data/grammars/latex.wrappers.json

@@ -0,0 +1,17 @@
+{
+  "format": "latexmath-wrappers/1",
+  "wrappers": {
+    "absent": "nil",
+    "items": "items",
+    "literal": "text",
+    "spelling": "text_list",
+    "text_list": "text_list"
+  },
+  "rules": {
+    "N1 text alternative": 144,
+    "N10 list site": 5,
+    "N11 named option": 8,
+    "N8 catalog text": 3246,
+    "N9 empty list": 4
+  }
+}