cton 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e7225331f668eaed1f9b9e85e4cfc6fd183b997a8a6a89b69a5300ad2fbc54c
-  data.tar.gz: 20cdff68722bc7dc8d7629b95c5ae47d6d0eb21a8be26ebc93cc32605a5ed329
+  metadata.gz: a1d32c4a3d5f55726071135d05705be7084d7c8332a1f03a5a724523981a7b81
+  data.tar.gz: '0813fb27119f36ab0117e7ca1401fe33d8826bc7bfbe09b68589dece8ae2f376'
 SHA512:
-  metadata.gz: 53f865fe83082953fae7cfa899c1c08014a21b0662d774253dc929c091eb4925c838007abfaeebdbacc3219a59751be0de1990d2230c9347a4d4e87ed9cc9753
-  data.tar.gz: b34df4bb7946e32feb693086892a410d9b440ba6374b3d3673e125b20ab7403c69bded90a43f5dd7683c3c54b889449965cfd136a7b180811a7ccb0a1ab185b9
+  metadata.gz: e536052cfe992ab7a5844640b622093a5d6f091edfa6af6ce456761e229fa1eb949ce50f103e9aadca54fa6abce66b0fc535fb5335c884e5de5bd2b29408d747
+  data.tar.gz: 66be8d4e9ff12a3e99dd138c82aa676cdc6e8f9e61a07183137b24de07b2f2d177c9a11b6e27e2407476dc45a19e3b012b63be87f942981a34002a6a292f791e

data/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.0] - 2026-01-17
+
+### Added
+
+- **Schema Validation DSL**: Define schemas via `Cton.schema` and validate data with `Cton.validate_schema` for LLM-safe outputs.
+- **Streaming APIs**: `Cton.load_stream`, `Cton.dump_stream`, plus `StreamReader`/`StreamWriter` for newline-delimited documents.
+- **CTON-B Binary Mode**: Optional binary envelope with compression via `Cton.dump_binary`/`Cton.load_binary`.
+- **CLI Enhancements**: `--schema`, `--stream`, `--to-binary`, and `--from-binary` support.
+
+### Changed
+
+- **Performance**: Faster scalar scans in the decoder and reusable scalar buffers in the encoder.
+- **Docs**: README refocused on LLM usage, schema validation, and streaming workflows.
+
 ## [0.4.0] - 2025-11-26
 
 ### Added

data/README.md

@@ -3,96 +3,73 @@
 [![Gem Version](https://badge.fury.io/rb/cton.svg)](https://badge.fury.io/rb/cton)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/davidesantangelo/cton/blob/master/LICENSE.txt)
 
-**CTON** (Compact Token-Oriented Notation) is an aggressively minified, JSON-compatible wire format that keeps prompts short without giving up schema hints. It is shape-preserving (objects, arrays, scalars, table-like arrays) and deterministic, so you can safely round-trip between Ruby hashes and compact strings that work well in LLM prompts.
+CTON (Compact Token-Oriented Notation) is a token-efficient, JSON-compatible wire format built for LLM prompts. It keeps structure explicit (objects, arrays, table arrays) while removing syntactic noise, so prompts are shorter and outputs are easier to validate. CTON is deterministic and round-trippable, making it safe for LLM workflows.
+
+**CTON is designed to be the reference language for LLM data exchange**: short, deterministic, schema-aware.
 
 ---
 
-## 📖 Table of Contents
+## Quickstart
 
-- [What is CTON?](#what-is-cton)
-- [Why another format?](#why-another-format)
-- [Examples](#examples)
-- [Token Savings](#token-savings-vs-json--toon)
-- [Installation](#installation)
-- [Usage](#usage)
-- [Performance & Benchmarks](#performance--benchmarks)
-- [Teaching CTON to LLMs](#teaching-cton-to-llms)
-- [Development](#development)
-- [Contributing](#contributing)
-- [License](#license)
+```bash
+bundle add cton
+```
 
----
+```ruby
+require "cton"
 
-## What is CTON?
+payload = {
+  "user" => { "id" => 42, "name" => "Ada" },
+  "tags" => ["llm", "compact"],
+  "events" => [
+    { "id" => 1, "action" => "login" },
+    { "id" => 2, "action" => "upload" }
+  ]
+}
 
-CTON is designed to be the most efficient way to represent structured data for Large Language Models (LLMs). It strips away the "syntactic sugar" of JSON that humans like (indentation, excessive quoting, braces) but machines don't strictly need, while adding "structural hints" that help LLMs generate valid output.
+cton = Cton.dump(payload)
+# => user(id=42,name=Ada)
+# => tags[2]=llm,compact
+# => events[2]{id,action}=1,login;2,upload
 
-### Key Concepts
+round_trip = Cton.load(cton)
+# => same as payload
+```
 
-1.  **Root is Implicit**: No curly braces `{}` wrapping the entire document.
-2.  **Minimal Punctuation**:
-    *   Objects use `key=value`.
-    *   Nested objects use parentheses `(key=value)`.
-    *   Arrays use brackets with length `[N]=item1,item2`.
-3.  **Table Compression**: If an array contains objects with the same keys, CTON automatically converts it into a table format `[N]{header1,header2}=val1,val2;val3,val4`. This is a massive token saver for datasets.
-4.  **Comments**: Single-line comments with `#` for annotating data.
-5.  **Validation API**: Check CTON syntax without full parsing for quick validation.
-6.  **Token Statistics**: Built-in measurement of token efficiency vs JSON.
-7.  **Custom Type Registry**: Register serializers for domain objects.
+```bash
+# CLI usage
+cton input.json
+cton --to-json data.cton
+cton --stats input.json
+```
 
 ---
 
-## Examples
+## Why CTON for LLMs?
 
-### Simple Key-Value Pairs
+- **Shorter prompts**: CTON removes braces, indentation, and repeated keys.
+- **Schema hints built-in**: arrays include length and tables include headers.
+- **Deterministic output**: round-trip safe and validates structure.
+- **LLM-friendly**: small grammar + clear guardrails for generation.
 
-**JSON**
-```json
-{
-  "task": "planning",
-  "urgent": true,
-  "id": 123
-}
-```
+---
+
+## CTON in 60 seconds
+
+### Objects & Scalars
 
-**CTON**
 ```text
 task=planning,urgent=true,id=123
 ```
 
 ### Nested Objects
 
-**JSON**
-```json
-{
-  "user": {
-    "name": "Davide",
-    "settings": {
-      "theme": "dark"
-    }
-  }
-}
-```
-
-**CTON**
 ```text
-user(name=Davide,settings(theme=dark))
+user(name=Ada,settings(theme=dark))
 ```
 
-### Arrays and Tables
-
-**JSON**
-```json
-{
-  "tags": ["ruby", "gem", "llm"],
-  "files": [
-    { "name": "README.md", "size": 1024 },
-    { "name": "lib/cton.rb", "size": 2048 }
-  ]
-}
-```
+### Arrays & Tables
 
-**CTON**
 ```text
 tags[3]=ruby,gem,llm
 files[2]{name,size}=README.md,1024;lib/cton.rb,2048
@@ -100,351 +77,146 @@ files[2]{name,size}=README.md,1024;lib/cton.rb,2048
 
 ---
 
-## Why another format?
-
-- **Less noise than YAML/JSON**: no indentation, no braces around the root, and optional quoting.
-- **Schema guardrails**: arrays carry their length (`friends[3]`) and table headers (`{id,name,...}`) so downstream parsing can verify shape.
-- **LLM-friendly**: works as a single string you can embed in a prompt together with short parsing instructions.
-- **Token savings**: CTON compounds the JSON → TOON savings.
+## LLM Prompt Kit (Recommended)
 
-### Token savings vs JSON & TOON
+System prompt template:
 
-- **JSON → TOON**: The [TOON benchmarks](https://toonformat.dev) report roughly 40% fewer tokens than plain JSON on mixed-structure prompts while retaining accuracy due to explicit array lengths and headers.
-- **TOON → CTON**: By stripping indentation and forcing everything inline, CTON cuts another ~20–40% of characters.
-- **Net effect**: In practice you can often reclaim **50–60% of the token budget** versus raw JSON, leaving more room for instructions or reasoning steps while keeping a deterministic schema.
+```markdown
+You are an expert in CTON (Compact Token-Oriented Notation). Convert between JSON and CTON following the rules below and preserve the schema exactly.
 
----
-
-## Installation
-
-Add the gem to your application:
-
-```bash
-bundle add cton
+Rules:
+1. Do not wrap the root in `{}`.
+2. Objects use `key=value` and nested objects use `key(...)`.
+3. Arrays are `key[N]=v1,v2` and table arrays are `key[N]{k1,k2}=v1,v2;v1,v2`.
+4. Use unquoted literals for `true`, `false`, and `null`.
+5. Quote strings containing reserved characters (`,`, `;`, `=`, `(`, `)`) or whitespace.
+6. Always keep array length and table headers accurate.
 ```
 
-Or install it directly:
+Few-shot example:
 
-```bash
-gem install cton
+```text
+JSON: {"team":[{"id":1,"name":"Ada"},{"id":2,"name":"Lin"}]}
+CTON: team[2]{id,name}=1,Ada;2,Lin
 ```
 
 ---
 
-## Usage
-
-```ruby
-require "cton"
+## Schema Validation (1.0.0)
 
-payload = {
-  "context" => {
-    "task" => "Our favorite hikes together",
-    "location" => "Boulder",
-    "season" => "spring_2025"
-  },
-  "friends" => %w[ana luis sam],
-  "hikes" => [
-    { "id" => 1, "name" => "Blue Lake Trail", "distanceKm" => 7.5, "elevationGain" => 320, "companion" => "ana", "wasSunny" => true },
-    { "id" => 2, "name" => "Ridge Overlook", "distanceKm" => 9.2, "elevationGain" => 540, "companion" => "luis", "wasSunny" => false },
-    { "id" => 3, "name" => "Wildflower Loop", "distanceKm" => 5.1, "elevationGain" => 180, "companion" => "sam", "wasSunny" => true }
-  ]
-}
+CTON ships with a schema DSL for validation inside your LLM pipeline.
 
-# Encode to CTON
-cton = Cton.dump(payload)
-# => "context(... )\nfriends[3]=ana,luis,sam\nhikes[3]{...}"
-
-# Decode back to Hash
-round_tripped = Cton.load(cton)
-# => original hash
-
-# Need symbols?
-symbolized = Cton.load(cton, symbolize_names: true)
-
-# Want a truly inline document? Opt in explicitly (decoding becomes unsafe for ambiguous cases).
-inline = Cton.dump(payload, separator: "")
-
-# Pretty print for human readability
-pretty = Cton.dump(payload, pretty: true)
-
-# Stream to an IO object (file, socket, etc.)
-File.open("data.cton", "w") do |f|
-  Cton.dump(payload, f)
+```ruby
+schema = Cton.schema do
+  object do
+    key "user" do
+      object do
+        key "id", integer
+        key "name", string
+        optional "role", enum("admin", "viewer")
+      end
+    end
+    key "tags", array(of: string)
+  end
 end
 
-# Toggle float normalization strategies
-fast  = Cton.dump(payload) # default :fast mode
-strict = Cton.dump(payload, decimal_mode: :precise)
+result = Cton.validate_schema(payload, schema)
+puts result.valid? # true/false
 ```
 
-### CLI Tool
+Schema files can be used from the CLI as well:
 
-CTON comes with a command-line tool for quick conversions:
+```ruby
+# schema.rb
+CTON_SCHEMA = Cton.schema do
+  object do
+    key "user", object { key "id", integer }
+  end
+end
+```
 
 ```bash
-# Convert JSON to CTON
-echo '{"hello": "world"}' | cton
-# => hello=world
-
-# Convert CTON to JSON
-echo 'hello=world' | cton --to-json
-# => {"hello":"world"}
-
-# Pretty print
-cton --pretty input.json
-
-# Minify (fully inline, no separators)
-cton --minify input.json
-
-# Validate CTON syntax
-cton --validate input.cton
-# => ✓ Valid CTON
-
-# Show token savings statistics
-echo '{"name": "test", "items": [1,2,3]}' | cton --stats
-# => JSON:  33 chars / 33 bytes (~9 tokens)
-# => CTON:  26 chars / 26 bytes (~7 tokens)
-# => Saved: 21.2% (7 chars, ~2 tokens)
+cton --schema schema.rb input.cton
 ```
 
-### Advanced Features
+---
 
-#### Comments
+## Streaming IO (1.0.0)
 
-CTON supports single-line comments using the `#` character:
+Handle newline-delimited CTON streams efficiently:
 
 ```ruby
-cton_with_comments = <<~CTON
-  # User configuration
-  user(
-    name=Alice,
-    # Age is optional
-    age=30
-  )
-CTON
-
-Cton.load(cton_with_comments)
-# => {"user" => {"name" => "Alice", "age" => 30}}
-
-# Add comments when encoding
-Cton.dump(data, comments: { "user" => "User configuration" })
+io = File.open("events.cton", "r")
+Cton.load_stream(io).each do |event|
+  # process event
+end
 ```
 
-#### Validation API
-
-Validate CTON syntax without full parsing:
-
 ```ruby
-# Quick validity check
-Cton.valid?("key=value")  # => true
-Cton.valid?("key=(broken")  # => false
-
-# Detailed validation with error info
-result = Cton.validate("key=(broken")
-result.valid?  # => false
-result.errors.first.message  # => "Expected '=' in object"
-result.errors.first.line     # => 1
-result.errors.first.column   # => 5
+io = File.open("events.cton", "w")
+Cton.dump_stream(events, io)
 ```
 
-#### Token Statistics
-
-Measure CTON's token efficiency compared to JSON:
-
-```ruby
-stats = Cton.stats(data)
-puts stats.savings_percent    # => 45.5
-puts stats.estimated_token_savings  # => 12
-
-# Full comparison
-puts stats.to_s
-# => JSON:  100 chars / 100 bytes (~25 tokens)
-# => CTON:   55 chars /  55 bytes (~14 tokens)
-# => Saved: 45.0% (45 chars, ~11 tokens)
-
-# Compare all format variants
-Cton::Stats.compare(data)
-# => { cton: {...}, cton_inline: {...}, json: {...}, ... }
-```
+---
 
-#### Custom Type Registry
+## CTON-B (Binary Mode)
 
-Register custom serializers for your domain objects:
+CTON-B is an optional binary envelope for compact transport (with optional compression):
 
 ```ruby
-class Money
-  attr_reader :cents, :currency
-  def initialize(cents, currency)
-    @cents = cents
-    @currency = currency
-  end
-end
-
-# Register as object
-Cton.register_type(Money) do |money|
-  { amount: money.cents, currency: money.currency }
-end
-
-Cton.dump("price" => Money.new(1999, "USD"))
-# => "price(amount=1999,currency=USD)"
-
-# Register as scalar
-Cton.register_type(UUID, as: :scalar) { |uuid| uuid.to_s }
-
-# Unregister when done
-Cton.unregister_type(Money)
+binary = Cton.dump_binary(payload)
+round_trip = Cton.load_binary(binary)
 ```
 
-#### Enhanced Error Reporting
+CLI:
 
-Parse errors include detailed context for debugging:
-
-```ruby
-begin
-  Cton.load("user(name=Alice,invalid")
-rescue Cton::ParseError => e
-  puts e.message       # => "Unterminated object at line 1, column 20"
-  puts e.line          # => 1
-  puts e.column        # => 20
-  puts e.source_excerpt  # => "...name=Alice,invalid"
-  puts e.suggestions   # => ["Did you forget a closing ')'?"]
-end
+```bash
+cton --to-binary input.json > output.ctonb
+cton --from-binary output.ctonb
 ```
 
-#### Extended Types
-CTON natively supports serialization for:
-- `Time` and `Date` (ISO8601 strings)
-- `Set` (converted to Arrays)
-- `OpenStruct` (converted to Objects)
-
-#### Table detection
-Whenever an array is made of hashes that all expose the same scalar keys, the encoder flattens it into a table to save tokens. Mixed or nested arrays fall back to `[N]=(value1,value2,...)`.
-
-#### Separators & ambiguity
-Removing every newline makes certain inputs ambiguous because `sam` and the next key `hikes` can merge into `samhikes`. The default `separator: "\n"` avoids that by inserting a single newline between root segments. You may pass `separator: ""` to `Cton.dump` for maximum compactness, but decoding such strings is only safe if you can guarantee extra quoting or whitespace between segments. When you intentionally omit separators, keep next-level keys alphabetic (e.g., `payload`, `k42`) so the decoder's boundary heuristic can split `...1payload...` without misclassifying numeric prefixes.
-
-#### Literal safety & number normalization
-Following the TOON specification's guardrails, the encoder now:
-- Auto-quotes strings that would otherwise be parsed as booleans, `null`, or numbers (e.g., `"true"`, `"007"`, `"1e6"`, `"-5"`) so they round-trip as strings without extra work.
-- Canonicalizes float/BigDecimal output: no exponent notation, no trailing zeros, and `-0` collapses to `0`.
-- Converts `NaN` and `±Infinity` inputs to `null`, matching TOON's normalization guidance so downstream decoders don't explode on non-finite numbers.
-
-#### Decimal normalization modes
-- `decimal_mode: :fast` (default) prefers Ruby's native float representation and only falls back to `BigDecimal` when scientific notation is detected, minimizing allocations on tight loops.
-- `decimal_mode: :precise` forces the legacy `BigDecimal` path for every float, which is slower but useful for audit-grade dumps where you want deterministic decimal expansion.
-- Both modes share the same trailing-zero stripping and `-0 → 0` normalization, so switching modes never affects integer formatting.
+Note: `--stream` with binary assumes newline-delimited binary frames.
 
 ---
 
 ## Performance & Benchmarks
 
-CTON focuses on throughput: encoder table schemas are memoized, scalar list encoding keeps a reusable buffer, floats avoid `BigDecimal` when they can, and the decoder slices straight from the raw string to sidestep `StringScanner` allocations. You can reproduce the numbers below with the bundled script:
+CTON focuses on throughput: memoized table schemas, low-allocation scalar streams, and fast boundary detection for inline docs.
+
+Run benchmarks:
 
 ```bash
 bundle exec ruby bench/encode_decode_bench.rb
-# customize input size / iterations
 ITERATIONS=2000 STREAM_SIZE=400 bundle exec ruby bench/encode_decode_bench.rb
 ```
 
-Latest results on Ruby 3.1.4/macOS (M-series), 1,000 iterations, `STREAM_SIZE=200`:
-
-| Benchmark | Time (s) |
-| --- | --- |
-| `cton dump` (:fast) | 0.626 |
-| `cton dump` (:precise) | 0.658 |
-| `json generate` | 0.027 |
-| `cton load` | 2.067 |
-| `json parse` | 0.045 |
-| `cton inline load` (separator=`""`, double payload) | 4.140 |
-
-`cton inline load` deliberately concatenates documents without separators to stress the new boundary detector; it now finishes without the runaway allocations seen in earlier releases.
-
 ---
 
-## Teaching CTON to LLMs
-
-Use this system prompt to teach an LLM how to understand and generate CTON:
-
-````markdown
-You are an expert in data serialization and specifically in CTON (Compact Token-Oriented Notation). CTON is a token-efficient data format optimized for LLMs that serves as a compact alternative to JSON.
-
-Your task is to interpret CTON input and convert it to JSON, or convert JSON input into valid CTON format, following the specification below.
-
-### CTON Specification
-
-CTON minimizes syntax characters (braces, quotes) while preserving structure and type safety.
-
-**1. Basic Structure (Key-Value)**
-- **Rule:** Do not use outer curly braces `{}` for the root object.
-- **Rule:** Use `=` to separate keys and values.
-- **Rule:** Use `,` to separate fields.
-- **Rule:** Do not use quotes around "safe" strings (alphanumeric, simple text).
-- **Example:** - JSON: `{"task": "planning", "urgent": true}`
-  - CTON: `task=planning,urgent=true`
-
-**2. Nested Objects**
-- **Rule:** Use parentheses `()` to denote a nested object instead of `{}`.
-- **Example:**
-  - JSON: `{"context": {"user": "Davide", "theme": "dark"}}`
-  - CTON: `context(user=Davide,theme=dark)`
-
-**3. Arrays of Objects (Table Compression)**
-- **Rule:** Use the syntax `key[count]{columns}=values` for arrays of objects to avoid repeating keys.
-- **Structure:** `key[Length]{col1,col2}=val1,val2;val1,val2`
-- **Details:** - `[N]` denotes the number of items in the array.
-  - `{col1,col2}` defines the schema headers.
-  - `;` separates distinct objects (rows).
-  - `,` separates values within an object.
-- **Example:**
+## CLI Reference
 
-JSON:
-```json
-{
-  "files": [
-    { "name": "README.md", "size": 1024 },
-    { "name": "lib.rb", "size": 2048 }
-  ]
-}
-```
-
-CTON: `files[2]{name,size}=README.md,1024;lib.rb,2048`
-
-**4. Type Safety & Literals**
-- **Booleans/Null:** `true`, `false`, and `null` are preserved as literals (unquoted).
-- **Numbers:** Integers and floats are written as is (e.g., `1024`, `3.14`).
-- **Escaping:** If a string value looks like a boolean, number, or contains reserved characters (like `,`, `;`, `=`, `(`, `)`), it must be wrapped in double quotes (e.g., `"true"`).
-
-### Examples for Training
-
-**Input (JSON):**
-```json
-{
-  "id": 123,
-  "active": true,
-  "metadata": {
-    "created_at": "2023-01-01",
-    "tags": "admin"
-  }
-}
+```bash
+cton [input]                 # auto-detect JSON/CTON
+cton --to-json input.cton     # CTON → JSON
+cton --to-cton input.json     # JSON → CTON
+cton --to-binary input.json   # JSON → CTON-B
+cton --from-binary input.ctonb
+cton --minify input.json      # no separators
+cton --pretty input.json
+cton --stream input.ndjson
+cton --schema schema.rb input.cton
 ```
-````
 
 ---
 
-## Type Safety
-
-CTON ships with RBS signatures (`sig/cton.rbs`) to support type checking and IDE autocompletion.
-
 ## Development
 
 ```bash
 bin/setup        # install dependencies
 bundle exec rake # run tests and rubocop
 bin/console      # interactive playground
-bundle exec ruby bench/encode_decode_bench.rb # performance smoke test
 ```
 
-To release a new version, bump `Cton::VERSION` and run `bundle exec rake release`.
+---
 
 ## Contributing
 

data/lib/cton/binary.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Cton
+  module Binary
+    MAGIC = "CTON".b
+    VERSION = 1
+    FLAG_COMPRESSED = 1
+
+    module_function
+
+    def dump(data, compress: true, **options)
+      payload = Cton.dump(data, **options).b
+      flags = 0
+
+      if compress
+        payload = Zlib.deflate(payload)
+        flags |= FLAG_COMPRESSED
+      end
+
+      header = MAGIC + [VERSION, flags].pack("CC")
+      header + encode_varint(payload.bytesize) + payload
+    end
+
+    def load(binary)
+      source = binary.to_s.b
+      raise Cton::Error, "Invalid CTON-B header" unless source.start_with?(MAGIC)
+
+      version = source.getbyte(4)
+      flags = source.getbyte(5)
+      raise Cton::Error, "Unsupported CTON-B version" unless version == VERSION
+
+      length, consumed = decode_varint(source, 6)
+      payload_start = 6 + consumed
+      payload = source.byteslice(payload_start, length)
+      raise Cton::Error, "Invalid CTON-B payload length" if payload.nil? || payload.bytesize < length
+
+      payload = Zlib.inflate(payload) if (flags & FLAG_COMPRESSED).positive?
+
+      Cton.load(payload)
+    end
+
+    def encode_varint(value)
+      bytes = []
+      remaining = value
+      while remaining >= 0x80
+        bytes << ((remaining & 0x7f) | 0x80)
+        remaining >>= 7
+      end
+      bytes << remaining
+      bytes.pack("C*")
+    end
+
+    def decode_varint(source, offset)
+      result = 0
+      shift = 0
+      index = offset
+
+      loop do
+        byte = source.getbyte(index)
+        raise Cton::Error, "Invalid CTON-B varint" unless byte
+
+        result |= (byte & 0x7f) << shift
+        index += 1
+        break if (byte & 0x80).zero?
+
+        shift += 7
+      end
+
+      [result, index - offset]
+    end
+  end
+end