polytypo 1.0.0

data/lib/polytypo/data/rules/order.json

@@ -0,0 +1,78 @@
+{
+  "spec": "1.0.0",
+  "$comment": "Single source of truth for pipeline order. Rules run in ascending `order`. Disabling a rule removes it from the sequence and never reorders the rest. Rule ids are public API (see docs/ARCHITECTURE.md section 5). \"spec\" here must track spec/VERSION exactly — it is not itself the global version source; scripts/validate-spec.mjs enforces the match.",
+  "rules": [
+    {
+      "id": "spaces",
+      "order": 10,
+      "default": "on",
+      "modes": ["text", "html", "markdown"],
+      "localeData": [],
+      "summary": "Collapse repeated spaces, strip spaces before punctuation, normalize spacing inside brackets."
+    },
+    {
+      "id": "ellipsis",
+      "order": 20,
+      "default": "on",
+      "modes": ["text", "html", "markdown"],
+      "localeData": ["ellipsis"],
+      "summary": "Three dots to U+2026; locale-dependent abbreviated forms after terminal punctuation."
+    },
+    {
+      "id": "ranges",
+      "order": 25,
+      "default": "off",
+      "modes": ["text", "html", "markdown"],
+      "localeData": ["dash"],
+      "summary": "Numeric/date range dash per locale convention (dash.range). Explicit opt-in (spec 0.5.0): a genuine range and a compound label sharing the same digit-hyphen-digit shape (`Figure 5-10`) cannot be told apart without the preceding word, which this project's rules are built never to consult. Off by default; enable with `{ rules: { ranges: true } }`."
+    },
+    {
+      "id": "dashes",
+      "order": 30,
+      "default": "on",
+      "modes": ["text", "html", "markdown"],
+      "localeData": ["dash"],
+      "summary": "Parenthetical dash per locale convention (dash.parenthetical). Never reinterprets a digit-flanked hyphen as a parenthetical dash — that shape belongs to `ranges` alone, whether or not `ranges` is enabled (spec 0.5.0; range detection moved out of this rule)."
+    },
+    {
+      "id": "hyphen",
+      "order": 35,
+      "default": "on",
+      "modes": ["text", "html", "markdown"],
+      "localeData": ["hyphen"],
+      "summary": "Bind morphological hyphen forms with U+2011 (non-breaking hyphen) so they cannot be broken across lines. Runs after `dashes`, which has already declined every letter-adjacent hyphen. A no-op for locales whose hyphen lists are empty."
+    },
+    {
+      "id": "quotes",
+      "order": 40,
+      "default": "on",
+      "modes": ["text", "html", "markdown"],
+      "localeData": ["quotes"],
+      "summary": "Straight quotes to locale primary/secondary pairs with nesting resolution. Runs before `apostrophe` so that a straight apostrophe is still available as quote evidence. Declines to pair an ambiguous medial short single-quoted span (spec 0.5.0) unless a cited `quotes.elisionIdioms` entry matches."
+    },
+    {
+      "id": "apostrophe",
+      "order": 50,
+      "default": "on",
+      "modes": ["text", "html", "markdown"],
+      "localeData": ["quotes"],
+      "summary": "Remaining straight apostrophes to U+2019 without corrupting contractions. As of spec 0.5.0, also reads `quotes.elisionIdioms` (indirectly, via the shared ambiguity predicate) to keep a straight-ASCII mark `quotes` deliberately preserved from being independently curled by this rule's own structural case ladder."
+    },
+    {
+      "id": "symbols",
+      "order": 60,
+      "default": "on",
+      "modes": ["text", "html", "markdown"],
+      "localeData": [],
+      "summary": "(c)/(r)/(tm) to the corresponding signs; multiplication sign between numerals."
+    },
+    {
+      "id": "nbsp",
+      "order": 70,
+      "default": "on",
+      "modes": ["text", "html", "markdown"],
+      "localeData": ["nbsp", "quotes"],
+      "summary": "Insert no-break and narrow no-break spaces per locale. Runs last so that every other rule has already settled the surrounding characters."
+    }
+  ]
+}

data/lib/polytypo/data/schema/fixtures.schema.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://polytypo.org/schema/fixtures.schema.json",
+  "title": "polytypo conformance fixtures",
+  "description": "Executable form of the rule semantics. Every case is also an idempotency case: a runner must additionally assert transform(out) == out.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["spec", "locale", "cases"],
+  "properties": {
+    "spec": {
+      "type": "string",
+      "description": "The current global spec contract version. Must equal spec/VERSION exactly — not an authoring-time stamp and not a per-case introduction version. scripts/validate-spec.mjs enforces this for every fixture root."
+    },
+    "locale": { "type": "string", "pattern": "^[a-z]{2}(-[A-Z]{2})?$" },
+    "cases": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "rule", "mode", "in"],
+        "allOf": [
+          {
+            "if": { "properties": { "mode": { "const": "markdown" } }, "required": ["mode"] },
+            "then": { "required": ["dialect"] },
+            "else": { "not": { "required": ["dialect"] } }
+          }
+        ],
+        "oneOf": [{ "required": ["out"] }, { "required": ["throws"] }],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$",
+            "description": "Stable, unique within the file. Convention: <locale>-<rule>-<what>."
+          },
+          "rule": {
+            "enum": [
+              "spaces",
+              "ellipsis",
+              "ranges",
+              "dashes",
+              "hyphen",
+              "quotes",
+              "apostrophe",
+              "symbols",
+              "nbsp"
+            ],
+            "description": "The rule under test. Required so a runtime can report partial conformance honestly."
+          },
+          "mode": { "enum": ["text", "html", "markdown"] },
+          "dialect": {
+            "enum": ["commonmark", "mdx"],
+            "description": "Required when mode is \"markdown\" — spec/rules/modes.md §3.7.1 forbids detection, so a fixture must name the dialect exactly as a caller would. Meaningless for the other modes."
+          },
+          "in": { "type": "string" },
+          "out": { "type": "string" },
+          "throws": {
+            "enum": [
+              "POLYTYPO_UNKNOWN_LOCALE",
+              "POLYTYPO_INVALID_MODE",
+              "POLYTYPO_INVALID_DIALECT",
+              "POLYTYPO_UNKNOWN_RULE",
+              "POLYTYPO_MALFORMED_LOCALE_DATA",
+              "POLYTYPO_RULE_CONTRACT",
+              "POLYTYPO_MALFORMED_INPUT"
+            ],
+            "description": "Expected error code instead of an output string. Messages are not part of the contract; codes are."
+          },
+          "note": { "type": "string" },
+          "rules": {
+            "type": "object",
+            "additionalProperties": { "type": "boolean" },
+            "description": "Optional rule overrides for this case, same shape as the public `rules` option."
+          }
+        }
+      }
+    }
+  }
+}

data/lib/polytypo/data/schema/locale.schema.json

@@ -0,0 +1,235 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://polytypo.org/schema/locale.schema.json",
+  "title": "polytypo locale data",
+  "description": "Declarative typographic conventions for one locale. Literal strings, literal code points, string lists and enum values only — no patterns, no priorities, no expressions (docs/ARCHITECTURE.md section 5.1).",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["locale", "name", "quotes", "dash", "ellipsis", "hyphen", "nbsp", "sources"],
+  "properties": {
+    "locale": {
+      "type": "string",
+      "pattern": "^[a-z]{2}(-[A-Z]{2})?$",
+      "description": "BCP-47 language or language-region tag. Must equal the file name."
+    },
+    "name": {
+      "type": "string",
+      "description": "English name of the locale, for generated documentation."
+    },
+    "quotes": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["primary", "secondary", "elisionIdioms"],
+      "properties": {
+        "primary": { "$ref": "#/$defs/quotePair" },
+        "secondary": { "$ref": "#/$defs/quotePair" },
+        "elisionIdioms": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/elisionIdiom" },
+          "uniqueItems": true,
+          "description": "Literal, closed-set elision idioms consulted only to decline pairing two NARROW quote marks as a quotation when the full context — the word immediately before the opening mark and the word immediately after the closing mark, not merely the elided content between them — matches (quotes.md 3.2's listed elision veto), e.g. English { left: \"rock\", elided: \"n\", right: \"roll\" } for \"rock 'n' roll\". Empty is the default and means no verified idiom of this shape — a missing citation is never a licence to guess. Matching the elided content alone (a bare word list) is insufficient and is not this field's shape: it cannot distinguish the idiom from an arbitrary quoted letter, e.g. \"The letter 'n' is common.\", which is exactly the false positive this three-part contract exists to avoid."
+        }
+      }
+    },
+    "dash": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["parenthetical", "range"],
+      "properties": {
+        "parenthetical": {
+          "enum": ["em-tight", "em-spaced", "en-tight", "en-spaced", "none"],
+          "description": "Dash used for a parenthetical break. `-tight` means no surrounding spaces, `-spaced` means a regular space on each side (the leading one may later be made non-breaking by the nbsp rule). `none` means the locale has no verified convention and the rule must not substitute anything."
+        },
+        "range": {
+          "enum": ["em-tight", "em-spaced", "en-tight", "en-spaced", "none"],
+          "description": "Dash used between numbers and dates. Russian sets an em dash here. `none` means the locale has no verified convention and the rule must not substitute anything — a missing citation is never a licence to guess."
+        }
+      }
+    },
+    "ellipsis": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["abbreviatedAfterTerminal"],
+      "properties": {
+        "abbreviatedAfterTerminal": {
+          "type": "boolean",
+          "description": "When true, an ellipsis directly after `!` or `?` is written with two dots (`?..`) rather than three. Russian convention."
+        }
+      }
+    },
+    "hyphen": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["prefixes", "suffixes", "compounds"],
+      "description": "Morphological forms whose hyphen must not break across lines. Empty arrays are the normal case — only a few languages have a normative list.",
+      "properties": {
+        "prefixes": {
+          "$ref": "#/$defs/wordList",
+          "description": "Word-initial forms written with a trailing hyphen, e.g. Russian \"кое-\"."
+        },
+        "suffixes": {
+          "$ref": "#/$defs/wordList",
+          "description": "Word-final forms written with a leading hyphen, e.g. Russian \"-таки\"."
+        },
+        "compounds": {
+          "$ref": "#/$defs/wordList",
+          "description": "Whole hyphenated forms, written with U+002D, e.g. Russian \"из-под\"."
+        }
+      }
+    },
+    "nbsp": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "beforePunctuation",
+        "narrowBeforePunctuation",
+        "afterShortWords",
+        "abbreviations",
+        "beforeUnits",
+        "beforeNumber",
+        "beforeWord",
+        "afterSymbols",
+        "initialBinding"
+      ],
+      "properties": {
+        "beforePunctuation": {
+          "$ref": "#/$defs/charList",
+          "description": "Characters that take U+00A0 before them. Q-P (quotes.md 2.1, enforced by scripts/validate-spec.mjs): every entry must be a member of the quotes rule's CLOSEISH."
+        },
+        "narrowBeforePunctuation": {
+          "$ref": "#/$defs/charList",
+          "description": "Characters that take U+202F before them. Q-P (quotes.md 2.1, enforced by scripts/validate-spec.mjs): every entry must be a member of the quotes rule's CLOSEISH."
+        },
+        "afterShortWords": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "uniqueItems": true,
+          "description": "Lowercase words that must not be left at the end of a line; the space after them becomes U+00A0. Matching is case-insensitive only for the first character."
+        },
+        "abbreviations": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 2 },
+          "uniqueItems": true,
+          "description": "Literal multi-token abbreviations written with regular U+0020; every internal space becomes U+00A0. Example: \"z. B.\"."
+        },
+        "beforeUnits": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "uniqueItems": true,
+          "description": "Units and signs that bind to a preceding number with U+00A0. Example: \"%\", \"km\", \"°C\"."
+        },
+        "beforeNumber": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 2 },
+          "uniqueItems": true,
+          "description": "Abbreviations that bind to a following number with U+00A0. Example: \"Nr.\", \"S.\", \"art.\"."
+        },
+        "beforeWord": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 2 },
+          "uniqueItems": true,
+          "description": "Abbreviations that bind to a following word with U+00A0. Example: \"г.\", \"ул.\", \"M.\", \"Mme\". Riskier than beforeNumber — list only forms whose binding is normative."
+        },
+        "afterSymbols": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 },
+          "uniqueItems": true,
+          "description": "Symbols that bind to a following number with U+00A0. Example: \"§\", \"№\"."
+        },
+        "initialBinding": {
+          "enum": ["none", "chain", "single"],
+          "description": "N7's mode (spec 0.6.0, replaces the boolean bindInitials). \"none\": N7 disabled. \"chain\": binds only a confirmed sequence of two or more adjacent initials (Chicago's own \"two or more initials\" wording) — a lone initial next to an ordinary capitalized word is left alone. \"single\": additionally binds one lone initial to a following word (Jacques André's citation), which cannot structurally distinguish every genuine name from a sentence-boundary collision."
+        }
+      }
+    },
+    "sources": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["rule", "cite"],
+        "properties": {
+          "rule": {
+            "enum": [
+              "quotes",
+              "dashes",
+              "ranges",
+              "ellipsis",
+              "hyphen",
+              "nbsp",
+              "spaces",
+              "apostrophe",
+              "symbols"
+            ],
+            "description": "Which rule the citation is normative for. Values are rule ids from spec/rules/order.json — note the rule is `dashes`/`ranges` while the locale-data field both read is `dash`."
+          },
+          "cite": {
+            "type": "string",
+            "minLength": 8,
+            "description": "Normative authority, named precisely enough to be looked up offline."
+          },
+          "url": { "type": "string", "format": "uri" },
+          "note": { "type": "string" }
+        }
+      },
+      "description": "Mandatory. Every locale-driven rule with non-default data must be covered by at least one citation (docs/PLAN.md section 6.1)."
+    }
+  },
+  "$defs": {
+    "quotePair": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["open", "close", "innerSpace"],
+      "properties": {
+        "open": { "$ref": "#/$defs/singleChar" },
+        "close": { "$ref": "#/$defs/singleChar" },
+        "innerSpace": {
+          "enum": ["none", "nbsp", "narrow-nbsp"],
+          "description": "Space inserted between the quotation mark and the quoted text, as in French guillemets."
+        }
+      },
+      "description": "Q-W (quotes.md 2.1, enforced by scripts/validate-spec.mjs): open and close must share a WIDE/NARROW visual width. Q-A: if innerSpace is not \"none\", neither open nor close may be U+2019."
+    },
+    "singleChar": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 2,
+      "not": { "enum": ["\"", "'"] },
+      "description": "Exactly one Unicode code point, written as the literal character. maxLength is 2 only because a JSON validator counts UTF-16 units; the one-code-point rule is enforced by scripts/validate-spec.mjs, which is the portable check. U+0022 and U+0027 are forbidden: the quotes rule reasons about straight marks as input and would not terminate if a locale declared one as output."
+    },
+    "wordList": {
+      "type": "array",
+      "items": { "type": "string", "minLength": 2 },
+      "uniqueItems": true
+    },
+    "charList": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/singleChar" },
+      "uniqueItems": true
+    },
+    "elisionIdiom": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["left", "elided", "right"],
+      "properties": {
+        "left": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Literal word immediately before the opening NARROW mark, separated from it by exactly one permitted inline-space code point. Matched as a whole word (quotes.md 3.2), first code point case-insensitive, the rest exact. Every code point must be LETTER (quotes.md 3.2's Word definition) — not because the engine's literal matcher would fail to match a digit or punctuation code point (it would match those exact bytes wherever they occur), but because an entry outside LETTER would make runtime behaviour exceed what the normative Word definition authorises. JSON Schema cannot express a Unicode-category constraint, so this is enforced by scripts/validate-spec.mjs and scripts/gen-locales.mjs against the same pinned table src/engine/unicode.ts imports, not by this schema."
+        },
+        "elided": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Literal content between the two NARROW marks, matched exactly, code point for code point, no case leniency. Not constrained to LETTER: the match is a literal equality test, not a Word-boundary walk."
+        },
+        "right": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Literal word immediately after the closing NARROW mark, separated from it by exactly one permitted inline-space code point. Matched as a whole word, first code point case-insensitive, the rest exact. Same LETTER-only constraint as \"left\", enforced the same way."
+        }
+      },
+      "description": "A closed-set elision idiom (quotes.md 3.2's listed elision veto). All three fields are required and non-empty: matching only `elided` cannot distinguish an idiom from an arbitrary quoted word and is not a supported shape."
+    }
+  }
+}

data/lib/polytypo/data/schema/registry.schema.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://polytypo.org/schema/registry.schema.json",
+  "title": "polytypo locale registry",
+  "description": "The only data locale resolution consumes (spec/rules/locale-resolution.md section 2). The three registry invariants — alias targets exist, aliases never shadow a locale, aliases are never transitive — are relational and are enforced by scripts/validate-spec.mjs, not expressible here.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["locales", "aliases"],
+  "properties": {
+    "spec": { "type": "string" },
+    "$comment": { "type": "string" },
+    "locales": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z]{2}(-[A-Z]{2})?$",
+        "description": "Concrete locale identifier with a file at spec/locales/<id>.json."
+      }
+    },
+    "aliases": {
+      "type": "object",
+      "description": "Maps a tag to a member of `locales`. A value is a final answer, never another alias key.",
+      "propertyNames": { "pattern": "^[a-z]{2}(-[A-Z]{2})?$" },
+      "additionalProperties": { "type": "string", "pattern": "^[a-z]{2}(-[A-Z]{2})?$" }
+    }
+  }
+}

data/lib/polytypo/data/schema/resolution.schema.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://polytypo.org/schema/resolution.schema.json",
+  "title": "polytypo locale-resolution fixtures",
+  "description": "Conformance cases for spec/rules/locale-resolution.md. Kept separate from spec/schema/fixtures.schema.json because a resolution case has no rule, no mode and no text — it maps a requested tag to a resolved locale or to an error code.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["spec", "cases"],
+  "properties": {
+    "spec": { "type": "string" },
+    "cases": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id"],
+        "oneOf": [{ "required": ["resolves"] }, { "required": ["throws"] }],
+        "allOf": [
+          {
+            "if": { "properties": { "tagAbsent": { "const": true } }, "required": ["tagAbsent"] },
+            "then": { "not": { "required": ["tag"] } },
+            "else": { "required": ["tag"] }
+          }
+        ],
+        "properties": {
+          "id": { "type": "string", "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$" },
+          "tag": {
+            "type": "string",
+            "description": "The tag as passed by the caller, verbatim — including any casing or separator the resolver is expected to accept or reject."
+          },
+          "tagAbsent": {
+            "const": true,
+            "description": "The caller supplied no locale at all, or a null one — the case spec/rules/locale-resolution.md §3.1 requires to throw. A closed flag rather than a widened `tag` type, so every runtime reads one intent instead of reinterpreting null, undefined and missing keys in its own way."
+          },
+          "resolves": {
+            "type": "string",
+            "pattern": "^[a-z]{2}(-[A-Z]{2})?$",
+            "description": "Canonical locale the tag must resolve to."
+          },
+          "throws": {
+            "enum": ["POLYTYPO_UNKNOWN_LOCALE"],
+            "description": "Resolution never falls back to English; an unresolvable tag throws."
+          },
+          "note": { "type": "string" }
+        }
+      }
+    }
+  }
+}

data/lib/polytypo/engine/codepoints.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Polytypo
+  module Engine
+    # String <-> code-point array conversion (docs/ARCHITECTURE.md section 4.2: rules index an
+    # explicit code-point array, never a native string). Ruby strings are already sequences of
+    # Unicode code points for a UTF-8-encoded String -- this module exists for cross-runtime
+    # consistency and because every rule below is written against "index i of the code-point
+    # array," not "index i of the string."
+    module Codepoints
+      def self.to_codepoints(str)
+        str.codepoints
+      end
+
+      def self.from_codepoints(cp)
+        cp.pack("U*")
+      end
+
+      def self.valid_codepoint?(value)
+        value.is_a?(Integer) && value >= 0 && value <= 0x10FFFF
+      end
+    end
+  end
+end

data/lib/polytypo/engine/edits.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "codepoints"
+require_relative "../errors"
+
+module Polytypo
+  module Engine
+    # One replacement a rule proposes: replace cp[start...end] with replacement. Indices address
+    # the code-point array, never a native string (docs/ARCHITECTURE.md section 4.2).
+    Edit = Struct.new(:start, :end, :replacement, :rule_id)
+
+    module Edits
+      # Enforces the rule contract rather than trusting it (rules are community-contributed):
+      # edits must be in bounds, ascending, non-overlapping, and made of real code points.
+      # rule_id is nil when validating a caller-agnostic batch.
+      def self.validate_edits(edits, length, rule_id = nil)
+        previous_end = 0
+        edits.each_with_index do |edit, i|
+          where = rule_id.nil? ? "edit #{i}" : "rule #{rule_id.inspect} edit #{i}"
+
+          if edit.start.negative? || edit.end > length
+            reject("#{where} is out of bounds (#{edit.start}, #{edit.end}) for length #{length}")
+          end
+          if edit.end < edit.start
+            reject("#{where} has end #{edit.end} before start #{edit.start}")
+          end
+          if edit.start < previous_end
+            reject("#{where} starts at #{edit.start}, which overlaps or precedes the previous edit")
+          end
+          if !rule_id.nil? && edit.rule_id != rule_id
+            reject("#{where} is tagged #{edit.rule_id.inspect} but was produced by rule #{rule_id.inspect}")
+          end
+          edit.replacement.each do |value|
+            unless Codepoints.valid_codepoint?(value)
+              reject("#{where} contains an invalid code point (#{value})")
+            end
+          end
+          previous_end = edit.end
+        end
+      end
+
+      # Applies validated edits left to right, producing a new code-point array.
+      def self.apply_edits(cp, edits, rule_id = nil)
+        validate_edits(edits, cp.length, rule_id)
+        return cp.dup if edits.empty?
+
+        out = []
+        cursor = 0
+        edits.each do |edit|
+          out.concat(cp[cursor...edit.start])
+          out.concat(edit.replacement)
+          cursor = edit.end
+        end
+        out.concat(cp[cursor..])
+        out
+      end
+
+      def self.reject(message)
+        raise Polytypo::Error.new(Polytypo::CODE_RULE_CONTRACT, message)
+      end
+      private_class_method :reject
+    end
+  end
+end