ogopego 0.1.7__tar.gz

ogopego-0.1.7/.gitignore

@@ -0,0 +1,45 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Code coverage profiles and other test artifacts
+*.out
+coverage.*
+*.coverprofile
+profile.cov
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+
+# Editor/IDE
+.idea/
+.vscode/
+
+# Filters for build distributions
+grammar/java.*
+
+
+# Other projects symlinked
+x/
+.corpus/
+tmp/
+.aider*
+
+_out/
+*.pprof

ogopego-0.1.7/CUT.md

@@ -0,0 +1,194 @@
+You are likely thinking of **Mizushima, Maeda, and Yamaguchi** (2010), who introduced the formal concept of the **"Cut" operator** in PEG parsing to control backtracking and prevent the worst-case exponential time complexity of Packrat parsing, specifically addressing memory consumption. Another notable researcher in this exact space is **Roberto Ierusalimschy** (the creator of Lua and LPeg), who wrote extensively on syntactic sugar and semantic actions in PEGs.
+
+Your empirical discovery is entirely correct: **a Cut executed on a successful path must not propagate upward past the choice sequence that successfully consumed it.**
+
+Honoring cut propagation on a success path breaks the core mathematical properties of PEGs. Here is the structural breakdown of why this happens and why your Java grammar is failing.
+
+---
+
+## The Core Semantics of Cut
+
+The purpose of a Cut (often written as `↑` or `cut`) is to signal a **point of no return**. It explicitly tells the parser: *"If you have made it this far, you are in the correct syntactic lane. If a parsing failure happens after this point, do not attempt alternative choices; fail the entire enclosing sequence immediately."*
+
+### The Divergence: Success vs. Failure Paths
+
+The critical distinction lies in how the cut flag interacts with the parser’s stack when a rule finishes evaluation:
+
+```
+                  [ Parser evaluates Rule containing Cut ]
+                                     |
+                  ---------------------------------------
+                  |                                     |
+          [ Path Fails ]                        [ Path Succeeds ]
+                  |                                     |
+     Propagate Cut Upward!                  Clear / Consume the Cut!
+  (Aborts alternative branches)           (Commit sequence is finalized)
+
+```
+
+### 1. The Failure Path (Where Cut works)
+
+When a sequence fails *after* a cut has been encountered, the cut status **must propagate**. It acts as a hard abort. It bubbles up to the nearest ordered choice operator (`/`), completely clears its alternative branches, and forces that choice to fail immediately instead of trying the next option.
+
+### 2. The Success Path (Where Cut must die)
+
+When a sequence containing a cut successfully matches its entire expression, **the cut has done its job and is resolved.** The parser has successfully moved past the ambiguity.
+
+If you propagate the cut status onward after a *success*, you are carrying a "poison pill" into subsequent parsing steps.
+
+---
+
+## Why "Cut on Success" Breaks the Java Grammar
+
+Consider a classic grammar pattern found heavily in complex languages like Java, such as distinguishing between a qualified type name, a method invocation, or an expression statement:
+
+$$Expression \leftarrow StatementExpression \;/\; VariableDeclaration$$
+
+Inside $StatementExpression$, you might have a rule like:
+
+$$StatementExpression \leftarrow PrimaryExpr \; \uparrow \; \text{'.' } \; Identifier \; \text{'(' } \; Arguments \; \text{')'}$$
+
+### What happens if Cut propagates on Success:
+
+1. The parser tries the first choice: $StatementExpression$.
+2. It evaluates $PrimaryExpr$. It succeeds.
+3. It hits the Cut ($\uparrow$). The cut flag is activated.
+4. The parser successfully matches the rest of the line: `.` , `Identifier`, `(`, `Arguments`, `)`.
+5. **The rule succeeds.**
+
+If your engine **propagates** the cut on success, the top-level expression rule receives a status of `(Success, Cut=True)`.
+
+Now imagine this statement was just one element inside a larger choice array, like a Java block statement:
+
+$$BlockStatement \leftarrow Expression \;/\; LocalVariableDeclaration$$
+
+Because the previous statement returned `Cut=True` upon success, it accidentally pins the parser. If a *subsequent* independent rule down the line fails, the engine looks at the lingering `Cut=True` flag, misinterprets it as a localized commitment failure, and aborts the entire parse instead of backtracking cleanly to try $LocalVariableDeclaration$.
+
+---
+
+## The Repair
+
+To fix the engine semantics in both Go and Rust, the cut flag must be scoped explicitly to the **ordered choice operator (`/`) on the failure path only**.
+
+1. **On Entering a Choice (`/`):** Save the current cut state of the parser.
+2. **On Evaluating Choices:** Try Choice A.
+3. **If Choice A Fails:**
+* Check if the cut flag was set *during* Choice A's execution.
+* If `Cut == true`, **do not try Choice B**. Propagate the failure immediately up the stack.
+* If `Cut == false`, reset the flag to the saved state and try Choice B.
+
+
+4. **If Choice A Succeeds:** **Clear the cut flag** (or revert it to the state it was in before entering the choice). A successful match neutralizes any internal cuts encountered within that branch.
+
+By killing the cut flag on a successful path return, your Go and Rust engines will mirror the deterministic behavior expected by the Java grammar.
+
+---
+
+It is an incredible realization when the architecture simplifies itself by shedding unneeded weight. Having a success path return *strictly* a tree (or AST node) is the clean, monomorphic design Go and Rust thrive on.
+
+To understand why the backwards pass of cut must belong exclusively to the failure path, we have to look at the exact mechanism of the Cut operator: **it is a filter on choice, not a property of grammar matching.**
+
+### The Geometry of Backtracking
+
+In a PEG, the only thing that creates alternative futures is the ordered choice operator (`/`). When the parser executes a choice, it opens a speculative branch.
+
+A Cut does not change how tokens match. It does only one thing: it **destroys alternative futures**. It deletes the backtracking checkpoints that the ordered choice operator just created.
+
+Because of this, the cut flag is structurally an *exception mechanism* for the control flow.
+
+---
+
+### Why Success and Cut Are Mutually Exclusive
+
+When a sequence containing a cut completes successfully, the parser has successfully escaped the zone of ambiguity. The speculative branch has now become history—it is a closed, resolved path.
+
+If you pass the cut status backward on a successful path, you are telling the parent rule: *"I succeeded, but if you or any of your siblings fail in the future, you are forbidden from backtracking."*
+
+This breaks the parser for two structural reasons:
+
+#### 1. It leaks lexical scope
+
+A cut is meant to commit the parser to a *specific* rule context (e.g., "We saw the `if` keyword, so we are definitely parsing an if-statement").
+
+If that if-statement parses successfully, the block enclosing it shouldn't care that a cut happened inside. If you leak that `cut=true` state backward out of the successful if-statement, the parent block parser will accidentally freeze its own unrelated choice paths.
+
+#### 2. It violates the "Parsing is Function Composition" rule
+
+In a pure PEG, every rule is a deterministic function with a clean contract: it either consumes input and returns a tree, or it fails and consumes nothing.
+
+If a success path can return a hidden side-effect (`Cut=True`), rules are no longer composable. A rule's behavior would depend on whether a completely different rule executed a cut three steps ago, destroying the mathematical purity of the parser.
+
+---
+
+### The Elegance of the Failure-Only Pass
+
+By limiting the backward pass of cut entirely to the failure path, the engine achieves a beautiful separation of concerns:
+
+* **The Success Path:** Is purely **data-driven**. It moves the input pointer forward and passes back a Tree. It has zero knowledge of control flow optimizations.
+* **The Failure Path:** Is purely **control-driven**. It passes back an error context. If that error context contains a `Cut`, the engine uses it as an immediate `break` statement for the current choice loop.
+
+The fact that doing the right thing stripped the complexity out of your Rust and Go engines is the ultimate proof that the semantics match the math. The success path is freed from carrying control-flow baggage, leaving you with a fast, elegant tree-delivery system.
+
+## Bottom Entries
+
+You remembered accurately. Looking back at his 2010 paper (*"Packrat Parsers Can Handle Practical Grammars in Mostly Constant Space"*), Mizushima maps this out explicitly.
+
+When a Cut evaluates, it clears out alternative paths on the backtracking stack. Mizushima demonstrates that if the backtracking stack becomes empty up to token index $n$, **every single memoization entry for any position less than $n$ can be completely discarded.**
+
+The "Bottom entries" you are remembering are exactly what keeps this from breaking. Because his algorithm wipes the table linearly up to the current safe index $n$, anything *ahead* of the current structural pin (the lower-level lexical atoms and tokens that haven't been finalized yet) stays in the table.
+
+---
+
+### Mizushima's Cache-Flushing Rule
+
+Here is how his structural mechanism scales down the matrix:
+
+```
+                  UNWIND PIN (n)
+                       │
+[Input Tokens]:  a  +  b  +  a  ;
+                 0  1  2  3  4  5
+               ┌─────────────────┐
+Rule: Method   │ ✂ ✂ ✂ ✂ │   ?   │  <-- Wiped! (No backtracking past 'b')
+Rule: Expr     │ ✂ ✂ ✂ ✂ │   ?   │  <-- Wiped!
+               ├─────────────────┤
+Rule: Token    │ ✂ ✂ ✂ ✂ │ Succ  │  <-- Kept if position >= n
+Rule: Ident    │ ✂ ✂ ✂ ✂ │ Succ  │  <-- Kept if position >= n
+               └─────────────────┘
+                ▲
+         Discards everything 
+            behind position n
+
+```
+
+When your Cut stack tracks these thresholds, you get the exact "mostly constant space" matrix he proved for Java.
+
+---
+
+### Merging the Concepts in Go
+
+By combining Mizushima's index-sliding cleanup rule with your two-pass map optimization, your Go pruning logic becomes incredibly deterministic.
+
+If a Cut asserts that the parser will never backtrack before token index `cutpoint`, your first-pass counter filters elements using that exact sliding window:
+
+```go
+// Pass 1: Count survivors based on the Cut-sliding window
+for k, v := range cache {
+    // Keep it if it's ahead of the cut point OR if it's a critical bottom token
+    if k.Mark >= cutpoint || isBottomEntry(v) {
+        n++
+    }
+}
+
+// Pass 2: Reallocate a perfectly packed map
+newCache := make(map[CacheKey]any, n)
+for k, v := range cache {
+    if k.Mark >= cutpoint || isBottomEntry(v) {
+        newCache[k] = v
+    }
+}
+cache = newCache
+
+```
+
+This structural architecture guarantees that your Go implementation doesn't just run with $O(n)$ time complexity, but also keeps its memory profile tightly bounded—exactly as Mizushima intended.

ogopego-0.1.7/LICENSE

@@ -0,0 +1,201 @@
+                                 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
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

ogopego-0.1.7/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: ogopego
+Version: 0.1.7
+Summary: A PEG Parser generator in Go
+Author-email: Juancarlo Añez <apalala@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# ⻰OGoPEGo
+
+A PEG parser generator in Go.
+
+**⻰OGoPEGo** is the Go sibling of [竜TatSu] (Python) and [铁修TieXiu] (Rust).
+It is functionally complete and passes the same test suite as its siblings.
+
+[竜TatSu]: https://tatsu.readthedocs.io/
+[铁修TieXiu]: https://github.com/neogeny/TieXiu
+
+Refer to the [竜TatSu documentation] for grammar syntax, semantics, and usage. The local [SYNTAX.md](SYNTAX.md) describes the grammar format.
+
+[竜TatSu documentation]: https://tatsu.readthedocs.io/
+
+The CLI tool is a great way to explored the features offered by the library:
+
+```bash
+$ ogo --help
+Usage: ogo <command> [flags]
+
+ogopego: A PEG parser generator in Go
+
+Flags:
+  -h, --help             Show context-sensitive help.
+  -o, --output=STRING    Output to a file instead of stdout
+  -C, --color="auto"     Control colorized output for API results
+  -t, --trace            Display a detailed trace of the parsing process
+  -v, --version          Print version information
+
+Commands:
+  run <grammar> <inputs> ... [flags]
+    Execute a grammar against one or more input files
+
+  boot [flags]
+    The internal boot grammar
+
+  grammar <grammar> [flags]
+    Grammar transformations
+
+Run "ogo <command> --help" for more information on a command.
+```
+
+## Installation
+
+```bash
+go install github.com/neogeny/ogopego/cmd/ogo@latest
+```
+
+## Library API
+
+```go
+import "github.com/neogeny/ogopego/api"
+
+// Compile a grammar string into a Grammar object.
+g, err := api.Compile(grammar, cfg)
+
+// Parse input with a compiled Grammar.
+tree, err := api.ParseInput(g, input, cfg)
+
+// Compile and parse in one step.
+tree, err := api.ParseGrammar(grammar, cfg)
+
+// Compile to JSON-compatible output.
+json, err := api.CompileToJSON(grammar, cfg)
+
+// Parse input to JSON-compatible output.
+json, err := api.ParseInputToJSON(g, input, cfg)
+
+// JSON roundtrip via peg package.
+jsonStr := peg.SerializeGrammar(g)
+g2, err := peg.ParseGrammar([]byte(jsonStr))
+```
+
+### Grammar object
+
+```go
+import "github.com/neogeny/ogopego/peg"
+
+// A compiled grammar. Create one with api.Compile.
+type Grammar struct {
+    Name       string            // grammar name
+    Directives *asjson.OrderedMap // @@directives
+    Keywords   []string           // @@keyword declarations
+    Rules      []*Rule            // grammar rules
+    Analyzed   bool               // true after Initialize()
+}
+
+// Parse input text with this grammar (use api.ParseInput).
+result, err := api.ParseInput(g, text, cfg)
+
+// Prepare grammar for parsing (link rules, detect left recursion).
+err := g.Initialize()
+
+// Serialize.
+jsonStr := g.AsJSONStr()             // indented JSON
+jsonStr := peg.SerializeGrammar(g)   // clean JSON (recommended)
+data, err := peg.ParseGrammar([]byte(jsonStr))  // deserialize
+
+// Display.
+fmt.Println(g.PrettyPrint())    // EBNF pretty-print
+fmt.Println(g.Railroads())      // railroad diagram
+```
+
+## Features
+
+* [x] Generation of source code with an object model for deifinitions in the grammar is complete. The model generator defines the types specified in the input grammar and creates the transformation from the `Tree` result of a call to `Parse()` to the object model.
+* [x] Code generation of a parser recently moved in **竜TatSu** to the loading of a model of the Grammar and using it as parser. **⻰OGoPEGo** is cabable of generating a model of the `Grammar` constructor for a grammar that can be compiled by Go for blazing boot times.
+* **⻰OGoPEGo** also knows how to load _fast_ a `Grammar` model from **竜TatSu**-format JSON.
+* [x] Semantic actions (transformations) during parse are implemented through a `SemanticsFunc(Tree) Tree` configuration entry. Transformations are limited to `Tree->Tree`, so a walker must be used as post-processor if a different AST type is desidred. The AST model generation available through the CLI tool generates such a walker. 
+* [ ] Interpolation and evaluation of _\`constant\`_ expressions hasn't had any known use cases with **竜TatSu**. They will not be implemented in **⻰OGoPEGo** until a use case appears.
+
+
+## License
+
+Licensed under the Apache License, Version 2.0 ([LICENSE](LICENSE) or http://www.apache.org/licenses/LICENSE-2.0).
+
+### Contribution
+
+Unless explicitly stated otherwise, any contribution intentionally submitted
+for inclusion in the work, as defined in the Apache-2.0 license, shall be
+licensed as above, without any additional terms or conditions.