pubid 1.15.19 → 2.0.0.pre.alpha.2

data/lib/pubid/nist/parser.rb

@@ -0,0 +1,1117 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Nist
+    # Parser class for NIST identifiers
+    # Single Responsibility: Parsing NIST identifier syntax
+    class Parser < Parslet::Parser
+      # Class-level parse method with preprocessing
+      # Handles data quality normalization before parsing
+      # Named explicitly to avoid conflict with Parslet's built-in parse method
+      def self.class_parse_with_preprocessing(input)
+        # Apply legacy update_codes normalization first, before any other preprocessing
+        cleaned = Core::UpdateCodes.apply(input.to_s.strip, :nist)
+
+        # Fix lowercase publisher at start
+        cleaned = cleaned.sub(/^nbs\b/i, "NBS")
+        cleaned = cleaned.sub(/^nist\b/i, "NIST")
+
+        # Fix publisher+series concatenation: "NISTIR" → "NIST IR", "NBSIR" → "NBS IR"
+        # Must come after lowercase publisher fix to catch "nistir" → "NISTIR" → "NIST IR"
+        cleaned = cleaned.gsub(
+          /^(NBS|NIST)(IR|FIPS|GCR|HB|MONO|MP|NCSTAR|NSRDS)/i, '\1 \2'
+        )
+
+        # Fix lowercase series (ir, sp, tn, etc.)
+        cleaned = cleaned.sub(/\b(ir|sp|tn|hb|fips|ams|vts)\b/i, &:upcase)
+
+        # Normalize LC to LCIRC (single definition of truth)
+        # Pattern: "LC" followed by space/dot/end should become "LCIRC"
+        # But don't change if already "LCIRC"
+        cleaned = cleaned.gsub(/\bLC\b(?!IRC)/, "LCIRC")
+
+        # Combine "NBS LCIRC" with space into "NBS.LCIRC" ONLY when followed by supplement marker
+        # This allows the circ_supplement_identifier rule to match the pattern
+        # Only apply to supplement cases, not regular LCIRC identifiers
+        cleaned = cleaned.gsub(/\bNBS LCIRC\b(?=.*\b(?:supp?|sup\+|r\d+\/)\d)/,
+                               "NBS.LCIRC")
+
+        # Convert MR format LCIRC supplements to space-separated format
+        # "NBS.LCIRC.145r11/1925" → "NBS LCIRC 145r11/1925" (convert series dot to space)
+        cleaned = cleaned.gsub(/\bNBS\.LCIRC\.(\d+r\d+\/\d{4})/,
+                               "NBS LCIRC \\1")
+        # Also handle without year: "NBS.LCIRC.145r11" → "NBS LCIRC 145r11"
+        cleaned = cleaned.gsub(/\bNBS\.LCIRC\.(\d+r\d+)\b/, "NBS LCIRC \\1")
+
+        # Fix Roman numerals: "1011-I-2" → keep as is, but fix spaces: "1011-I-2 0" → "1011-I-2.0"
+        cleaned = cleaned.gsub(/([-\d]+[IVX]+[-\d]+)\s+(\d+)/, '\1.\2')
+
+        # Fix rev without space: "126rev2013" → "126 rev2013" (separate number from rev+year)
+        # BUT preserve edition+revision patterns: "e2rev1908" stays as-is
+        cleaned = cleaned.gsub(/(?<!e)(\d)(rev\d{4})/, '\1 \2')
+
+        # Fix LCIRC revision with slash and year: "145r6/1925" → "145 r6/1925"
+        # BUT NOT for LCIRC series (keep "NBS LCIRC 145r11/1925" as-is for parser)
+        # The circ_supplement_identifier rule expects "145r11" (no space)
+        unless cleaned.include?("LCIRC") || cleaned.include?("CIRC")
+          cleaned = cleaned.gsub(/(\d)(r\d+\/\d{4})/, '\1 \2')
+        end
+
+        # Fix LCIRC revision with just year (no slash): "1128r1995" → "1128 r1995"
+        # BUT preserve edition+revision patterns: "13e2rev1908" stays as-is
+        # AND preserve month abbreviations in patterns like "107-Mar1985" (ar1985 contains 'r')
+        # Use word boundary to ensure 'r' is standalone, not part of a month name
+        # AND preserve "rv" (revision year) patterns: "1013rv1953" stays as-is
+        cleaned = cleaned.gsub(/\b(r(?!v)\d{4})\b/, ' \1')
+
+        # Fix month in revision: "4743rJun1992" → "4743 rJun1992" (NEW)
+        cleaned = cleaned.gsub(/(\d)(r[A-Z][a-z]{2,8}\d{4})/, '\1 \2')
+        # REMOVED: Revision with 1-2 digits + lowercase letter preprocessing
+        # This is now handled by the more comprehensive fix at lines 131-142
+        # which keeps "22r1a" together (no space) for second_number pattern matching
+
+        # CRITICAL: Normalize lowercase letter suffix to uppercase
+        # Fix dash-letter pattern: "6529-a" → "6529-A" (FIXED - was incorrect)
+        # BUT preserve lowercase for NCSTAR series when letter is followed by volume (e.g., "1-1av1")
+        cleaned = cleaned.gsub(/(\d)-([a-z])$/) { "#{$1}-#{$2.upcase}" }
+
+        # Fix direct letter suffix (no dash): "378g" → "378G", "1000a" → "1000A"
+        # MUST come after dash pattern to avoid conflicts
+        # Fix letter suffix at end: "1011-A" → "1011A", "97-3b" → "97-3B"
+        # CRITICAL: Exclude r+digit pattern (e.g., "73-197r", "6945r") from this conversion
+        # These should remain as lowercase for edition pattern matching
+        # Only match single letter at end, not part of words like "index", "sec", etc.
+        cleaned = cleaned.gsub(/(\d)([a-z&&[^r]])$/) { "#{$1}#{$2.upcase}" }
+        # Also fix r+letter patterns (e.g., "22r1a" → "22r1A") separately
+        cleaned = cleaned.gsub(/(\d)(r)(\d+)([a-z])$/) do
+          "#{$1}#{$2}#{$3}#{$4.upcase}"
+        end
+        # NEW: Fix letter suffix before r (e.g., "53ar1" → "53Ar1")
+        # For patterns like NIST SP 800-53ar1 where letter is between number and revision
+        cleaned = cleaned.gsub(/(\d)([a-z])(r\d)/) { "#{$1}#{$2.upcase}#{$3}" }
+        # NOTE: Removed uppercase letter before r rule - it was breaking 800-56Ar2 parsing
+        # The parser should handle 56Ar2 as a single unit (letter suffix + revision)
+
+        # Fix letter suffix before volume: "1-2bv1" → "1-2Bv1" (MR format)
+        # BUT preserve "rv" (revision year) patterns: "1013rv1953" stays as-is
+        # Skip for NCSTAR to preserve lowercase letters (patterns like "1-1av1" should stay lowercase)
+        is_ncstar = cleaned.include?("NCSTAR")
+        unless is_ncstar
+          cleaned = cleaned.gsub(/(\d)([a-z&&[^r]])(v\d+)/) do
+            "#{$1}#{$2.upcase}#{$3}"
+          end
+        end
+
+        # Fix space before volume number: "80-2073 2" → "80-2073 v2" (Session 219)
+        # This handles NBS IR 80-2073 2 and NBS IR 80-2073 3 as volume identifiers
+        cleaned = cleaned.gsub(/(\d{2}-\d{4})\s+(\d)$/, '\1 v\2')
+
+        # Fix draft with number: "8270-draft2" → "8270 -draft 2" (Session 253)
+        # Space BEFORE dash AND after draft to separate it from report_number
+        cleaned = cleaned.gsub(/(\d)-draft(\d)/, '\1 -draft \2')
+
+        # NEW FIX 2: Draft without dash: "8270draft2" → "8270 -draft 2"
+        # More lenient pattern to catch missing dash before draft
+        cleaned = cleaned.gsub(/(\d)draft(\d)/, '\1 -draft \2')
+
+        # Fix supplement typo: "154suprev" → "154supprev" (Session 219)
+        cleaned = cleaned.gsub(/(\d)suprev/, '\1supprev')
+
+        # Fix letter suffix + revision before draft: "140Cr1-draft2" → "140C r1-draft2" (Session 221)
+        # Must be BEFORE general draft preprocessing at line 47
+        cleaned = cleaned.gsub(/(\d{2,})([A-Z])(r\d+)([-\s]draft\d*)/,
+                               '\1\2 \3\4')
+
+        # Convert Roman numeral volumes to Arabic per NIST spec (page 7)
+        # "1011-I-2.0" → "1011 v1 ver2.0"
+        # "1011-II-1.0" → "1011 v2 ver1.0"
+        cleaned = cleaned.gsub(/(\d+)-([IVX]+)-(\d+(?:\.\d+)*)/) do
+          number = $1
+          roman = $2
+          version_part = $3
+
+          # Convert Roman to Arabic
+          arabic = roman_to_arabic(roman)
+
+          # Convert to volume+version format
+          "#{number} v#{arabic} ver#{version_part}"
+        end
+
+        # Fix LCIRC supplement with slash and year: "118supp3/1926" → "118 supp3/1926"
+        cleaned = cleaned.gsub(/(\d)(supp\d+\/\d{4})/, '\1 \2')
+
+        # Fix Pt pattern: "800-57Pt3r1" → "800-57 pt3 r1"
+        cleaned = cleaned.gsub(/(\d)Pt(\d+)(r\d+)/, '\1 pt\2 \3')
+
+        # Fix version patterns: "ver1e2006" → "ver1 e2006", "ver2v1" → "ver2 v1"
+        cleaned = cleaned.gsub(/(\d)ver(\d)/, '\1 ver \2')
+        cleaned = cleaned.gsub(/ver(\d+)e(\d{4})/, 'ver\1 e\2')
+        cleaned = cleaned.gsub(/ver(\d+)v(\d+)/, 'ver\1 v\2')
+
+        # Fix dotted version: separate from number "268v1.1" → "268 v1.1"
+        cleaned = cleaned.gsub(/(\d)(v\d+\.\d+)/, '\1 \2')
+
+        # CRITICAL: Now separate dotted versions from preceding digits: "268v1.1" → "268 v1.1" (NEW)
+        cleaned = cleaned.gsub(/(\d)(v\d+\.\d+)/, '\1 \2')
+
+        # NEW: Separate version from number AND convert spaces to dots in one step
+        cleaned = cleaned.gsub(/(\d)(v\d+)\s+(\d+)$/, '\1 \2.\3')               # Two-part: "268v1 1" → "268 v1.1"
+        cleaned = cleaned.gsub(/(\d)(v\d+)\s+(\d+)\s+(\d+)$/, '\1 \2.\3.\4')    # Three-part: "63v1 0 1" → "63 v1.0.1"
+
+        # Fix volume ranges: "535v2a-l" → "535 v2a-l", "535v2m-z" → "535 v2m-z"
+        cleaned = cleaned.gsub(/(\d)(v\d+[a-z]-[a-z])/, '\1 \2')
+
+        # NEW: Fix volume with uppercase letter: "48v3B" → "48 v3B" (Session 220)
+        cleaned = cleaned.gsub(/(\d)(v\d+[A-Z])/, '\1 \2')
+
+        # NEW: Fix volume ranges with uppercase: "v2A-L" → "v2a-l" (normalize to lowercase) (Session 220)
+        cleaned = cleaned.gsub(/(v\d+)([A-Z])-([A-Z])/, '\1\2-\3'.downcase)
+
+        # NEW: Fix edition with "ed." suffix: "2006ed." → "e2006" (V1 compatibility)
+        # Pattern appears at end of identifier: "NIST SP 260-162 2006ed."
+        cleaned = cleaned.gsub(/(\d{4})ed\./, 'e\1')
+
+        # CRITICAL: Fix revision attached to number BEFORE update patterns!
+        # "8115r1-upd" → "8115 r1-upd" so that later "r1-upd" → "r1 -upd" works
+        # But preserve r6/1925 format (don't add space before slash/year)
+        # And preserve 300-8r1/upd format (don't separate r1/upd)
+        # ENHANCED: Also handle r1a (revision with letter suffix) - "800-22r1a" → "800-22r1A"
+        # FIXED: When there's a letter suffix, keep together for second_number pattern
+        # CRITICAL: Use \d{1,2} instead of \d+ to limit revision to 1-2 digits, allowing [a-z] to match
+        # First rule: Match r+digit+letter (keep together)
+        cleaned = cleaned.gsub(/(\d+)(r\d{1,2})([a-z])(?=-|[A-Z]|$)/) do
+          num = $1
+          rev = $2
+          letter = $3
+          # Keep together when there's a letter suffix
+          "#{num}#{rev}#{letter.upcase}"
+        end
+        # Second rule: Match r+digit WITHOUT letter suffix
+        # CRITICAL: Use negative lookahead (?![a-zA-Z]) to avoid matching when there's a letter
+        # PRESERVE compact format (no space) when at end of string (NIST SP 800-53r4)
+        # ADD space only when followed by: dash+uppercase, uppercase letter, or /upd, /errata, /insert
+        cleaned = cleaned.gsub(/(\d+)(r\d{1,2})(?![a-zA-Z])(?=[A-Z]|-(?=[A-Z])|\/(?:upd|errata|insert))/) do
+          num = $1
+          rev = $2
+          # Add space when followed by dash+uppercase, uppercase, or update keyword
+          "#{num} #{rev}"
+        end
+
+        # Fix spaces in version/volume numbers: "v1 1" → "v1.1", "1011-I-2 0" → "1011-I-2.0"
+        # ENHANCED to handle multiple spaces: "v1 0 1" → "v1.0.1", "v1 0 2" → "v1.0.2"
+        # FIXED: Pattern must start with "v" or digit to avoid matching "rev 2013" as "v" + " 2013"
+        # CRITICAL: Added word boundary \b to prevent matching "v" within "rev"
+        # CRITICAL FIX: Use \b to ensure match starts at word boundary
+        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*[-A-Z]*)\s+(\d+)(?!(?i:pd|wd|prd)\b)\s+(\d+)(?!(?i:pd|wd|prd)\b)/, '\1.\2.\3') # Three parts
+        # CRITICAL FIX: Use \b to ensure match starts at word boundary.
+        # Negative lookahead: don't swallow the digit of a numeric draft
+        # stage ("189 2pd" must stay split, not become "189.2pd"); letter
+        # stages ("ipd") already don't match the trailing \d+.
+        cleaned = cleaned.gsub(/(\b(?:v|\d)[v\d]*)\s+(\d+)(?!(?i:pd|wd|prd)\b)/, '\1.\2') # Two parts
+
+        # Fix update patterns: ensure space before -upd or /upd (not just at end)
+        # Enhanced to handle optional digits after upd: -upd, -upd1, /upd, /upd1
+        cleaned = cleaned.gsub(/(\d+)-upd(\d*)/, '\1 -upd\2')    # -upd or -upd1
+        cleaned = cleaned.gsub(/(\d+)\/upd(\d*)/, '\1 /upd\2')   # /upd or /upd1
+        cleaned = cleaned.gsub(/([a-z]\d+)-upd/, '\1 -upd')      # r1-upd → r1 -upd
+        cleaned = cleaned.gsub(/([a-z]\d+)\/upd/, '\1 /upd')     # After revision: r1/upd → r1 /upd
+
+        # NEW FIX 3: MR format with letter suffix before update: "8286C-upd1" → "8286C -upd1"
+        # Must handle uppercase letters before -upd in MR format
+        cleaned = cleaned.gsub(/(\d+[A-Z])-upd(\d*)/, '\1 -upd\2')  # Letter suffix + update
+        cleaned = cleaned.gsub(/(\d+[A-Z])\/upd(\d*)/, '\1 /upd\2') # Letter suffix + /upd variant
+
+        # Fix supplement patterns: ensure space before supplement (1st variant)
+        # "118supp3" already handled at line 32-33, but add "sup" variant
+        cleaned = cleaned.gsub(/(\d)(sup\d)/, '\1 \2') # 100-2sup1 → 100-2 sup1
+        # Fix supplement patterns: ensure space before supplement (2nd variant)
+        cleaned = cleaned.gsub(/(\d)(sup+)(\d)/, '\1 \2\3') # 100-2sup+1 → 100-2 sup+1
+        # Fix supplement patterns: ensure space before supplement (3rd variant)
+        cleaned = cleaned.gsub(/(\d)(sup\+)(\d)/, '\1 \2\3') # 100-2sup+1 → 100-2 sup+1
+        # Fix supplement patterns: ensure space before supplement (4th variant)
+        cleaned = cleaned.gsub(/(\d)(sup\d+)/, '\1 \2') # 100-2sup1 → 100-2 sup1
+        # Fix supplement patterns: ensure space before supplement (5th variant)
+        cleaned = cleaned.gsub(/(\d)(sup\d+\b)/, '\1 \2') # 100-2sup1 → 100-2 sup1
+
+        # Fix letter suffix + supplement: "378Gsup" → "378Gsupp" (NEW for LCIRC patterns)
+        # Normalize "sup" to "supp" for letter suffix patterns to match circ_supplement_identifier rule
+        cleaned = cleaned.gsub(/(\d+[A-Z])sup(\b)/, '\1supp\2') # 378Gsup → 378Gsupp
+
+        # Fix LCIRC supplement without letter suffix: "118sup12/1926" → "118supp12/1926"
+        # Normalize "sup" to "supp" for LCIRC patterns to match circ_supplement_identifier rule
+        cleaned = cleaned.gsub(/(\d+)sup(\d+\/\d{4})/, '\1supp\2') # 118sup12/1926 → 118supp12/1926
+
+        # Unify dashed/undashed year supplements: "supp-YYYY" → "suppYYYY".
+        # A bare dash before a 4-digit year is not semantic — "25supp-1924" and
+        # "25supp1924" denote the same publication (the genuine edition marker is
+        # explicit "e", e.g. "25suppe1924"). Collapsing the dash here gives both
+        # spellings ONE parse tree (the normal first_number path), so they build
+        # to an identical Circular with supplement=<year>, with equal ==/URN.
+        # Guard: 4 digits NOT followed by another digit or a slash, so the
+        # dash-slash form "supp-12/1926" (supplement_dash_slash_year) is untouched.
+        cleaned = cleaned.gsub(/(\d)(supp?)-(\d{4})(?![\d\/])/, '\1\2\3') # 25supp-1924 → 25supp1924
+
+        # REMOVED: Revision letter patterns that add space before revision with letter
+        # These conflicted with the fix at lines 131-142 which keeps "22r1a" together
+        # for second_number pattern matching. The comprehensive fix now handles:
+        # - "800-22r1a" → "800-22r1A" (kept together, uppercase letter)
+        # - "800-22r1" → "800-22 r1" (space added when no letter suffix)
+
+        # Fix number with letter suffix followed by standalone 'r': "56ar" → "56a r" (NEW)
+        cleaned = cleaned.gsub(/(\d[a-z])r\b/, '\1 r')
+
+        # Fix revision followed by language code: "r1es" → "r1 es", "r1pt" → "r1 pt" (NEW)
+        cleaned = cleaned.gsub(/(r\d+)(es|pt|chi|viet|port|esp)\b/, '\1 \2')
+
+        # Fix MR format translation codes: ".spa" → " spa", ".por" → " por", ".ind" → " ind" (NEW)
+        # Prevents 3-letter translation codes from being parsed as letter suffixes
+        # "NIST.SP.1262.spa" → "NIST.SP.1262 spa" (convert dot to space)
+        cleaned = cleaned.gsub(/^([A-Z]+)\.SP\.(\d+)\.([a-z]{2,4})$/,
+                               '\1.SP.\2 \3')
+        cleaned = cleaned.gsub(/^([A-Z]+)\.([A-Z]+)\.(\d+)\.([a-z]{2,4})$/,
+                               '\1.\2.\3 \4')
+
+        # ENHANCEMENT 1: Edition year normalization (-YYYY → eYYYY)
+        # Per NIST spec, trailing -YYYY should normalize to eYYYY format
+        # Pattern: number (optionally with non-e letter suffix) followed by dash and 4-digit year
+        # Examples: "330-2019" → "330e2019", "304a-2017" → "304Ae2017"
+        # Must NOT match existing edition patterns like "11e2-1915" (e2 is edition, -1915 is separate)
+        # Must be at end or before space to avoid breaking number-number patterns like "800-53"
+        # Negative lookbehind (?<![eE-]) prevents matching after e/E or dash (avoids e2-1915 and 105-1-1990)
+        # EXCLUSION: Do NOT convert -YYYY for HB series (handbooks) - preserve original format
+        # Example: "NBS HB 130-1979" should stay as "NBS HB 130-1979" (not convert to e1979)
+        # EXCLUSION: Do NOT convert -YYYY when preceded by "e\d+" (edition+year pattern like "44e2-1955")
+        # EXCLUSION: Only convert years in NBS (1901-1988) or NIST (1988-2099) range
+        # Numbers outside this range are part numbers, not edition years (e.g., SP 250-1039)
+        # Use a more specific pattern: only convert when NOT preceded by "e" + digits (edition)
+        # AND only convert when year is in valid range (1901-2099)
+        cleaned = cleaned.gsub(/(?<!e\d)(?<![eE-])(\d(?:[A-DF-Z]?))-(\d{4})(?=\s|$)/) do |match|
+          prefix = $1 # Number with optional letter
+          year = $2.to_i
+          # Only convert to edition format if year is in valid range
+          if year.between?(1901, 2099)
+            "#{prefix}e#{year}"
+          else
+            match # Keep dash format for part numbers (e.g., 250-1039)
+          end
+        end
+        # Revert the conversion for HB series to preserve -YYYY format
+        # Matches both "HB 130e1979" and "HB 105-1e1990" patterns
+        # Use [^:\s.]*? (exclude dots) to avoid consuming MR format dot separators
+        # This prevents "NIST.HB.135e2022" from being incorrectly reverted
+        cleaned = cleaned.gsub(/\b(HB|HB\s+)[^:\s.]*?(\d+)e(\d{4})(?=\s|$)/,
+                               '\1\2-\3')
+        # Revert the conversion for OWMWP series to preserve date format MM-DD-YYYY
+        # OWMWP uses date as the number: "06-13-2018" (not an edition)
+        # Pattern: "OWMWP 06-13e2018" → "OWMWP 06-13-2018"
+        cleaned = cleaned.gsub(
+          /\b(OWMWP|OWMWP\s*)[^:\s]*?(\d{2})-(\d{2})e(\d{4})(?=\s|$)/, '\1\2-\3-\4'
+        )
+        # Revert the conversion for RPT series to preserve year range format YYYY-YYYY
+        # Report series uses year ranges as the number: "1946-1947" (not an edition)
+        # Pattern: "RPT 1946e1947" → "RPT 1946-1947"
+        # Note: This must check that first year < second year (forward range)
+        cleaned = cleaned.gsub(/\b(RPT|RPT\s*)([^:\s]*?)(\d{4})e(\d{4})(?=\s|$)/) do |match|
+          prefix = $1 # "RPT" or "RPT "
+          separator = $2 # "." or "" or other non-colon, non-space chars
+          first_year = $3.to_i
+          second_year = $4.to_i
+          # Only revert if first < second (year range like 1946-1947)
+          if first_year < second_year
+            "#{prefix}#{separator}#{first_year}-#{second_year}"
+          else
+            match # Keep e format for editions like e2018e2019
+          end
+        end
+
+        # ENHANCEMENT 2: Version normalization (v1.1 → ver1.1, Ver. 2.0 → ver2.0)
+        # Normalize short v format to verbose ver format per NIST spec
+        # Already handled in version rule, but normalize in preprocessing for consistency
+
+        # CRITICAL: MR format version normalization must come BEFORE general v normalization
+        # Pattern: "NIST.SP.500-281-v1.0" → "NIST.SP.500-281.ver1.0"
+        # This allows report_number to match "500-281" and version rule to match ".ver1.0"
+        cleaned = cleaned.gsub(/-v(\d+\.\d+)/, '.ver\1')
+
+        # Handle Ver. with period: "Ver. 2.0" → "ver2.0" (remove period and space)
+        cleaned = cleaned.gsub(/\bVer\.\s+(\d+(?:\.\d+)*)/, 'ver\1')
+        # Handle verbose "v" to "ver": "v1.1" → "ver1.1" (only with dots - versions have dots)
+        cleaned = cleaned.gsub(/\bv(\d+\.\d+(?:\.\d+)*)/, 'ver\1')
+
+        # Fix uppercase P for part: "428P1" → "428 p1", "647P2" → "647 p2" (NEW)
+        cleaned = cleaned.gsub(/(\d)P(\d)/, '\1 p\2')
+
+        # Normalize part notation: "p1" → "pt1", "n1" → "pt1" for consistency
+        # This handles patterns like "61p1" → "61pt1" and "467n1" → "467pt1"
+        # MUST come AFTER uppercase P normalization
+        # EXCLUDE pattern: {number}p{digit}{4-digit-year} like "28p11969" (part + year, not part notation)
+        # Use negative lookahead to avoid matching when p/n + digit is followed by exactly 4 digits (year)
+        cleaned = cleaned.gsub(/\b([pn])(\d+)(?!\d{4}\b)/, 'pt\2')
+
+        # Fix complex part patterns in MR format: ensure space before part
+        cleaned = cleaned.gsub(/(\d)([pP]\d+)/, '\1 \2') # .467p1adde1 → .467 p1adde1, 800-57p1 → 800-57 p1
+
+        # Fix CRPL-F series: ensure space after series (e.g., "CRPL-F-B150" → "CRPL-F-B 150")
+        cleaned = cleaned.gsub(/(NBS CRPL-F-[AB])(\d)/, '\1 \2')
+        cleaned = cleaned.gsub(/(CRPL-F-[AB])(\d)/, '\1 \2')
+
+        # Extract volume from number: "17-917v3" → "17-917 v3", "1-1v1" → "1-1 v1"
+        # Pattern: digits-digits followed by v and digits (GCR, NCSTAR patterns)
+        # MUST be specific to avoid breaking existing "v1.1" patterns
+        cleaned = cleaned.gsub(/(\d+-\d+)(v\d+)(?![.\d])/, '\1 \2') # Negative lookahead for dots
+
+        # pd_suffix rule handles " 2pd" directly (space >> digits >> str("pd"))
+        # No preprocessing needed - adding space before "pd" breaks the parser
+
+        # Fix "Suppl" with space: "955 Suppl" → "955Suppl"
+        cleaned = cleaned.gsub(/(\d+)\s+Suppl\b/, '\1Suppl')
+
+        # Fix verbose "Version" format: " Version 2" → " ver 2"
+        cleaned = cleaned.gsub(/\s+Version\s+(\d+)/, ' ver \1')
+
+        # Fix verbose "Revision" format: " Revision (r)" → " r"
+        cleaned = cleaned.gsub(/\s+Revision\s+\(r\)/, " r")
+
+        # Fix verbose "Part N" → short "ptN": "800-57 Part 2 Rev. 1" →
+        # "800-57pt2 Rev. 1". The grammar already accepts short "ptN" (and
+        # "ptN Rev. M"); only the verbose spelling was unsupported. Attaches
+        # to the preceding number so the existing part rule applies.
+        cleaned = cleaned.gsub(/\s+Part\s+(\d+)/, 'pt\1')
+
+        # Normalize verbose addendum " Add"/" add" (with or without period)
+        # to the canonical " Add." the grammar accepts, and uppercase a
+        # doc-number letter that immediately precedes it ("800-38a Add" →
+        # "800-38A Add.") — NIST doc-number letters are canonically uppercase
+        # and the letter_number grammar rule only splits the uppercase form.
+        # Scoped to the addendum context so bare markers like "800-90r"
+        # (revision) are left untouched.
+        cleaned = cleaned.gsub(/(\d[a-z]?)\s+Add\b\.?/i) { "#{Regexp.last_match(1).upcase} Add." }
+
+        # Fix verbose "rev YYYY" format: "126 rev 2013" → "126r2013"
+        # Removes space between number and "rev", and converts to "r" prefix
+        # Handles patterns like "NIST SP 260-126 rev 2013" → "NIST SP 260-126r2013"
+        cleaned = cleaned.gsub(/(\d+)\s+rev\s+(\d{4})/, '\1r\2')
+
+        # Fix historical "report ;" format: "NBS report ; 8079" → "NBS RPT 8079"
+        # The semicolon and "report" (spelled out) are historical formats
+        cleaned = cleaned.gsub(/\breport\s*;\s*/, "RPT ")
+        cleaned = cleaned.gsub(/\breport\b/, "RPT")
+
+        # REMOVED: Incorrect dot preprocessing that treated dots as number separators
+        # This was semantically wrong - dots are PART separators in NIST!
+        # DELETE: cleaned = cleaned.gsub(/(\d{3,})\.(\d{1,4})(?=\s|$)/, '\1_\2')
+
+        # REMOVED: Incorrect space-to-underscore that treated as single number
+        # DELETE: cleaned = cleaned.gsub(/(\d{3,})\s+(\d{1,2})$/, '\1_\2')
+
+        # Detect format before parsing
+        format = detect_format(input.to_s)
+
+        # Use parslet parser instance
+        result = new.parse(cleaned)
+
+        # Add format to result
+        if result.is_a?(Hash)
+          result.merge(parsed_format: format)
+        elsif result.is_a?(Array)
+          # For array results, merge all hashes into one
+          # This handles cases where identifier rule returns multiple components (e.g., compound_series + edition)
+          merged = result.inject({}) do |acc, hash|
+            next acc unless hash.is_a?(Hash)
+
+            acc.merge(hash)
+          end
+          merged.merge(parsed_format: format)
+        else
+          result
+        end
+      end
+
+      # Detect format from input string
+      # :mr if contains dots (machine-readable: NIST.SP.800-53)
+      # :short otherwise (default: NIST SP 800-53)
+      def self.detect_format(input)
+        # Check if it has dot separators (MR format pattern)
+        # Patterns include:
+        # - "NIST.SP.800-53" (publisher.series.number)
+        # - "FIPS.46e1977" (series.numberWithEdition)
+        # - "NBS.HB.28pt1e1969" (publisher.series.part.edition)
+        # Key indicator: dots between components instead of spaces
+        if input.include?(".") && !input.match?(/\s/)
+          :mr
+        else
+          :short
+        end
+      end
+
+      # Convert Roman numerals to Arabic numbers
+      # I→1, II→2, III→3, IV→4, V→5, VI→6, VII→7, VIII→8, IX→9, X→10
+      def self.roman_to_arabic(roman)
+        case roman
+        when "I" then "1"
+        when "II" then "2"
+        when "III" then "3"
+        when "IV" then "4"
+        when "V" then "5"
+        when "VI" then "6"
+        when "VII" then "7"
+        when "VIII" then "8"
+        when "IX" then "9"
+        when "X" then "10"
+        else roman # Fallback for unexpected patterns
+        end
+      end
+
+      # Basic building blocks
+      rule(:space) { str(" ") }
+      rule(:dot) { str(".") }
+      rule(:dash) { str("-") }
+      rule(:slash) { str("/") }
+      rule(:digit) { match("[0-9]") }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match("[A-Za-z]") }
+      rule(:upper_letter) { match("[A-Z]") }
+      rule(:lower_letter) { match("[a-z]") }
+
+      # Hash prefix for machine-readable formats
+      rule(:hash_prefix) { str("#") }
+
+      # Month abbreviations
+      rule(:month_abbrev) do
+        str("January") | str("February") | str("March") | str("April") |
+          str("May") | str("June") | str("July") | str("August") |
+          str("September") | str("October") | str("November") | str("December") |
+          str("Jan") | str("Feb") | str("Mar") | str("Apr") |
+          str("Jun") | str("Jul") | str("Aug") | str("Sep") | str("Oct") | str("Nov") | str("Dec")
+      end
+
+      # Language codes for translations - 2-4 letter codes
+      # Supports: " spa", "(spa)", ".spa" (MR format)
+      rule(:language_code) do
+        ((space | dot).maybe >> (str("es") | str("pt") | str("chi") | str("viet") | str("port") | str("esp") |
+         match("[a-z]").repeat(2, 4))).as(:translation)
+      end
+
+      # Stage ID: i (initial), f (final), 1-9 (numbered iterations)
+      rule(:stage_id) do
+        str("i") | str("I") | str("f") | str("F") |
+          str("1") | str("2") | str("3") | str("4") | str("5") |
+          str("6") | str("7") | str("8") | str("9")
+      end
+
+      # Stage type: pd (public draft), wd (work-in-progress), prd (preliminary)
+      rule(:stage_type) do
+        str("pd") | str("PD") | str("wd") | str("WD") | str("prd") | str("PRD")
+      end
+
+      # Old style stage: (IPD), (FPD), (2PD) - parenthetical at document start
+      rule(:old_stage) do
+        str("(") >> (stage_id.as(:stage_id) >> stage_type.as(:stage_type)).as(:stage) >> str(")")
+      end
+
+      # New style stage: " ipd", ".ipd" - inline at document end
+      rule(:new_stage) do
+        (space | dot) >> (stage_id.as(:stage_id) >> stage_type.as(:stage_type)).as(:stage)
+      end
+
+      # Publisher
+      rule(:publisher) do
+        (str("NBS") | str("NIST")).as(:publisher)
+      end
+
+      # Compound series (include publisher in series name) - must be checked FIRST
+      rule(:compound_series) do
+        (
+          # Longest patterns first to avoid partial matches
+          str("NBS BRPD-CRPL-D") | str("NBS CRPL-F-A") | str("NBS CRPL-F-B") |
+          str("NBS CS-E") | str("CSRC Building Block") | str("CSRC Use Case") | str("CSRC Book") |
+          str("ITL Bulletin") | str("NSRDS-NBS") |
+          # NBS and NIST specific patterns that conflict with simple series
+          # CRITICAL: Put longer patterns before shorter to avoid partial matches!
+          str("NIST LCIRC") | str("NBS LCIRC") | str("NIST.LCIRC") | str("NBS.LCIRC") | str("NBS RPT") |
+          str("NIST PS") | str("NIST DCI") | str("NIST Other") |
+          str("NISTPUB") |
+          str("NBS CSM") | str("NBS CIRC") | str("NBS.CRPL") | str("NBS CRPL") | str("NBS CS") |
+          str("NBS CIS") | str("NBS HR") | str("NBS IRPL") | str("NBS IP") | str("NBS PS") |
+          str("NBS BH")
+        ).as(:series)
+      end
+
+      # Simple series (no publisher prefix)
+      rule(:simple_series) do
+        (
+          str("AMS") | str("VTS") | # NEW - Added for NIST AMS and VTS series
+          str("BSS") | str("BMS") | str("BH") |
+          str("FIPS") | str("GCR") | str("HB") | str("MONO") |
+          str("MP") | str("NCSTAR") | str("NSRDS") | str("IR") |
+          str("SP") | str("TN") | str("CSWP") |
+          str("AI") | str("CIRC") | str("CS") | str("CSM") |
+          str("CRPL") | str("LCIRC") | str("OWMWP") | str("PC") | str("RPT") |
+          str("SIBS") | str("TIBM") | str("TTB") | str("EAB") |
+          str("JPCRD") | str("JRES")
+        ).as(:series)
+      end
+
+      # Suffix letter(s) after number - supports single letters and specific two-letter suffixes
+      # Two-letter suffixes: Ur (Unclassified Revised), Ua (Unclassified Amended), Ub-Uj (series variants)
+      # Single letter: any letter not followed by excluded keywords
+      rule(:number_suffix) do
+        (str("U") >> lower_letter) | (match("[a-zA-Z]") >> (
+          # Match suffixes
+          str("ec") |
+          str("ndex") |
+          str("nsert") |
+          str("rrata") |
+          str("raft") | # NEW: Exclude "draft" from number suffix matching
+          str("pp") |
+          str("s") |
+          str("t") |
+          str("hi") |
+          str("iet") |
+          str("ort") |
+          str("r") | # NEW: Exclude "r" revision marker (e.g., r5, r1963)
+          str("p") # NEW: Exclude "p" part marker (e.g., 28p11969 - part with year pattern)
+        ).absent? >>
+          digits.maybe)
+      end
+
+      rule(:digits_with_suffix) do
+        digits >>
+          # Suffix only if not followed by digit (e.g., don't match 'e' in '140e2')
+          (number_suffix >> digit.absent?).maybe
+      end
+
+      # Report number - first part - support edition prefixes like "e104" and supplement suffixes like "144supp"
+      # Supplements should be handled as separate parts
+      rule(:first_number) do
+        (
+          # OWMWP date format: MM-DD-YYYY (e.g., 06-13-2018)
+          # Must be FIRST to match before other dash patterns
+          (match("[0-9]").repeat(2, 2).as(:owmwp_month) >> dash >>
+           match("[0-9]").repeat(2, 2).as(:owmwp_day) >> dash >>
+           match("[0-9]").repeat(4, 4).as(:owmwp_year)).as(:owmwp_date_number) |
+          # Special text patterns - MOST SPECIFIC FIRST (NEW for RPT patterns)
+          str("ADHOC") | (str("div") >> digits) |
+          # Month ranges for RPT: Apr-Jun1948 (NEW)
+          (month_abbrev >> dash >> month_abbrev >> digits) |
+          # Number with volume suffix (e.g., "539v10" for CIRC, "1011v1" for general patterns)
+          # CRITICAL: Must be before CS series pattern to avoid consuming "GB" as letter suffix
+          (digits.as(:number) >> str("v") >> digits.as(:volume_suffix)).as(:number_with_volume) |
+          # Roman numeral patterns: 1011-I-2.0, 1011-II-1.0 (ENHANCED to accept optional dots)
+          (digits >> dash >> (str("III") | str("II") | str("IV") | str("I") | str("V") | str("VI") | str("VII") | str("VIII") | str("IX") | str("X")) >> dash >> digits >> (dot >> digits).maybe) |
+          # GB series pattern: 1190GB-1, 1190GB-4A
+          (digits >> str("GB") >> dash >> digits >> upper_letter.maybe) |
+          # CS series pattern with letter in middle: 102E-42, 123A-50
+          (digits >> upper_letter >> dash >> digits) |
+          # Volume-number format for CSM series: v6n1, v7n12
+          # CHANGED: Capture volume and issue_number separately for proper semantics
+          (str("v") >> digits.as(:volume_number) >> str("n") >> digits.as(:issue_number)) |
+          # Regular number with supplement and revision suffix: "154supprev"
+          (digits >> str("supprev")) |
+          # Regular number with edition and revision year-only: "13e2rev1908"
+          (digits >> str("e") >> digits >> str("rev") >> digits) |
+          # NEW: Number with revision year (rv pattern for LetterCircular): "1013rv1953"
+          (digits.as(:number) >> str("rv") >> digits.as(:revision_year)).as(:number_with_rev_year) |
+          # Regular number with edition, revision, and month-date: "13e2revJune1908"
+          (digits >> str("e") >> digits >> str("rev") >> month_abbrev >> digits) |
+          # Regular number with eN suffix and optional supplement (e.g., "101e2supp") - most specific
+          (digits >> str("e") >> digits >> str("supp") >> digits.maybe) |
+          # Edition prefix with revision and date: e2revJune1908
+          (str("e") >> digits >> str("rev") >> month_abbrev >> digits) |
+          # Edition prefix followed by digits and optional supplement with digits
+          (str("e") >> digits >> str("supp") >> digits.maybe) |
+          # Regular number with eN suffix (e.g., "101e2")
+          (digits >> str("e") >> digits) |
+          # NEW: Bare edition (just "e2" without number prefix)
+          (str("e") >> digits >> (dash >> digits).absent?) |
+          # Letter prefix with digits (e.g., "c4" for CRPL)
+          (lower_letter >> digits) |
+          # Regular number with supplement suffix with month/year (e.g., "24suppJan1924")
+          (digits >> str("supp") >> month_abbrev >> digits) |
+          # Regular number with supplement suffix (e.g., "144supp") - with optional digits
+          (digits >> str("supp") >> digits.maybe) |
+          # Regular number with supplement suffix followed by month/year for date range
+          (digits >> str("sup") >> month_abbrev >> digits) |
+          # Regular number with "sup" suffix (e.g., "9350sup") - NEW for RPT patterns
+          (digits >> str("sup")) |
+          # Language code suffix without separator (e.g., "1088sp")
+          # Must come BEFORE general suffix pattern to capture specific language codes
+          # Must come AFTER other patterns (like sup, supp, etc.) to avoid consuming them
+          # Note: Preprocessing doesn't convert attached suffixes, so we handle both cases
+          (digits.as(:number) >> (str("sp") | str("pt") | str("es") | str("SP") | str("PT") | str("ES")).as(:language_code) >> (upper_letter.absent? >> digit.absent? >> letter.absent? >> dash.absent? >> dot.absent?)) |
+          # Part+edition suffix for MR format: "28pt1e1969" (part notation + edition year)
+          # Handles patterns like "NBS.HB.28pt1e1969" where part and edition are attached
+          # Must come BEFORE language code pattern to take priority
+          (digits.as(:number) >> str("pt") >> digits.as(:part_number) >> str("e") >> digits.as(:edition_year)) |
+          # Parenthetical language code (e.g., "378(sp)")
+          # Must come AFTER other patterns to avoid consuming letter suffixes
+          # Note: Preprocessing converts content inside parentheses to uppercase
+          # Use specific patterns to avoid consuming other parenthetical content
+          (digits.as(:number) >> str("(") >> (str("SP") | str("PT") | str("ES")).as(:language_code) >> str(")")) |
+          # Regular number with optional suffix (original) - includes letters like "A"
+          digits_with_suffix
+        ).as(:first_number)
+      end
+
+      # Second number (after dash) - allow pt suffix, letter suffixes, and CRPL patterns
+      rule(:second_number) do
+        # Explicitly exclude month abbreviations at start (so -Feb1985 goes to edition, not second_number)
+        month_abbrev.absent? >>
+          # NEW: Exclude "draft" keyword
+          str("draft").absent? >>
+          (
+            # Trailing bare supplement marker on a compound second number
+            # (e.g. "800-53sup") so it isn't split into "53s" + "up". Builder
+            # strips the marker and sets supplement="" (canonical "sup").
+            (digits >> (str("supp") | str("sup")) >>
+              (digit.absent? >> letter.absent?)) |
+            # NEW: Revision pattern with U+letter suffix (e.g., "22r1Ua", "38Ua")
+            # MUST come BEFORE general letter suffix to avoid matching just "U" from "Ua"
+            (digits >> str("r") >> digits >> str("U") >> lower_letter) |
+            # NEW: Revision pattern with letter suffix (e.g., "22r1a", "22r1A" for SP patterns)
+            # This allows second_number to match the entire "22r1A" as a single unit
+            # MUST come BEFORE plain r+digits to avoid greedy match of just "22r1"
+            (digits >> str("r") >> digits >> match("[a-zA-Z]")) |
+            # NEW: Revision pattern with year (e.g., "126r2013")
+            # This handles SP revision format where revision is attached to second_number
+            (digits.as(:number_only) >> str("r") >> digits.as(:edition_id)) |
+            # CRPL range with underscore (e.g., "2_3-1A")
+            (digits >> str("_") >> digits >> dash >> digits >> upper_letter.maybe) |
+            # Letter followed by dash and digits (e.g., "m-5")
+            (lower_letter >> dash >> digits) |
+            # Number with pt suffix (e.g., "57pt1")
+            # EXCLUDE pt#-# patterns (e.g., "pt3-1") which are part components for CRPL
+            # Use negative lookahead to prevent matching when followed by dash
+            (digits >> str("pt") >> digits >> dash.absent?) |
+            # Number with uppercase letter suffix (e.g., "56A", "123B") - for patterns like "56Ar2"
+            (digits >> upper_letter) |
+            # NEW: Revision pattern where r is directly followed by a letter (e.g., "27ra" -> rA)
+            # For patterns like NIST SP 800-27ra where revision 'ra' is attached directly to number
+            (digits.as(:number_only) >> str("r") >> match("[a-zA-Z]").as(:letter)).as(:revision_letter) |
+            # NEW: Revision pattern where r is directly followed by a letter without leading digits (e.g., "rA")
+            # For patterns like NIST SP 800-27ra where revision 'ra' is attached directly to number
+            (str("r") >> match("[a-zA-Z]")).as(:revision_letter_suffix) |
+            # NEW: Simple revision pattern r followed by digits (e.g., "r1", "r2") for trailing revision
+            (str("r") >> digits.as(:edition_id)).as(:revision_simple) |
+            # Special patterns like "NCNR", "PERMIS", "BFRL"
+            str("NCNR") | str("PERMIS") | str("BFRL") |
+            # Just capital letters (e.g., "A", "B", "C") - standalone
+            upper_letter.repeat(1, 3) |
+            # Regular number with optional suffix - but NOT if part of FIPS date (digit-dash-month-digit-slash)
+            (digits_with_suffix >> (dash >> month_abbrev >> digits >> slash).absent?) |
+            # Single lowercase letter (e.g., "a", "b") - but NOT "r" followed by digits (edition marker)
+            # This is for patterns like "126a" but not "126r2"
+            (lower_letter >> digit.absent?)
+          ).as(:second_number)
+      end
+
+      # Edition component per NIST spec: <edition-type><edition-id>
+      # Type: "e" (edition), "r" (revision), "rev" (revision verbose), "-" (historical)
+      # ID: number (1-9) or year (yyyy)
+      # Examples: e2, e2021, r5, rev2013, rev 2013, -3
+      # Enhanced: Support space-separated format from preprocessing (r1 separated from number)
+      rule(:edition) do
+        # Edition with "e" prefix: e2, e3, e2021 (1-4 digits for ID)
+        (space.maybe >> str("e") >> digits.as(:edition_id)).as(:edition_e) |
+          # Revision with "r" prefix and SPACE, with letter: r 5A (preserve format)
+          (space >> str("r") >> digits.as(:edition_id) >> match("[a-zA-Z]").as(:edition_letter)).as(:edition_r_with_space_letter) |
+          # Revision with "r" prefix and SPACE: r 5 (preserve format)
+          (space >> str("r") >> digits.as(:edition_id)).as(:edition_r_with_space) |
+          # Revision with "r" prefix NO space, with letter: r5A (compact format)
+          (str("r") >> digits.as(:edition_id) >> match("[a-zA-Z]").as(:edition_letter)).as(:edition_r_no_space_letter) |
+          # Revision with "r" prefix NO space: r5 (compact format)
+          (str("r") >> digits.as(:edition_id)).as(:edition_r_no_space) |
+          # Revision with "rev" prefix (verbose): rev2013, rev 2013
+          (space.maybe >> str("rev") >> space.maybe >> digits.as(:edition_id)).as(:edition_rev) |
+          # Historical with "-" prefix: -2, -3 (ONLY if followed by non-digit or end)
+          # This avoids consuming date patterns like "-1908"
+          # Historical precedent uses small numbers (1-9), dates use 4-digit years
+          (dash >> match("[1-9]").as(:edition_id) >> digit.absent?).as(:edition_historical) |
+          # Edition dash-year pattern: -1979, -1990 (dash + 4-digit year)
+          # This matches year-only editions like "NBS HB 130-1979"
+          (dash >> match("[0-9]").repeat(4,
+                                         4).as(:dash_year)).as(:edition_dash_year)
+      end
+
+      # Date component per NIST spec: -{YYYY} or -{YYYYMM} or -{YYYYMMDD}
+      # Separate from Edition - both can coexist
+      # Examples: -1908, -190806, -19770930
+      rule(:date) do
+        (
+          # Date with month and day: -19770930 (YYYYMMDD)
+          (dash >> match("[0-9]").repeat(4, 4).as(:date_year) >>
+           match("[0-9]").repeat(2, 2).as(:date_month) >>
+           match("[0-9]").repeat(2, 2).as(:date_day)) |
+          # Date with month: -190806 (YYYYMM)
+          (dash >> match("[0-9]").repeat(4, 4).as(:date_year) >>
+           match("[0-9]").repeat(2, 2).as(:date_month)) |
+          # Date with year only: -1908 (YYYY)
+          (dash >> match("[0-9]").repeat(4, 4).as(:date_year)) |
+          # Legacy month format: -June1908, -Jan1925 (normalize to YYYYMM)
+          (dash >> month_abbrev.as(:date_month) >> digits.as(:date_year))
+        ).as(:date)
+      end
+
+      # LEGACY EDITION PATTERNS (for backward compatibility during migration)
+      # These will be gradually replaced as we migrate to proper Edition/Date components
+      rule(:legacy_edition) do
+        # Complex revision patterns: r1a, r2b
+        ((str("r") | str(" R")) >> match("[0-9]").repeat(1,
+                                                         2).as(:edition) >> lower_letter.as(:edition_letter)) |
+          # Edition with revision and year: rev2013, rev2020, rev 2013 (with space)
+          (str("rev") >> space.maybe >> digits.as(:edition_year)) |
+          # Edition with revision and date: e2revJune1908 (will migrate to e2 + date)
+          ((str("e") | str(" E")) >> match("[0-9]").repeat(1, 3).as(:edition) >>
+           str("rev") >> match("[A-Za-z]").repeat(3,
+                                                  9).as(:edition_month) >> digits.as(:edition_year)) |
+          # Edition with year and month: e201801 (ambiguous - could be e2018 or year 2018 month 01)
+          (str("e") >> match("[0-9]").repeat(4,
+                                             4).as(:edition_year) >> match("[0-9]").repeat(
+                                               2, 2
+                                             ).as(:edition_month).maybe) |
+          # Revision-based edition: revJune1908, revJan1925 (normalize to date)
+          (str("rev") >> match("[A-Za-z]").repeat(3,
+                                                  9).as(:edition_month) >> digits.as(:edition_year))
+      end
+
+      # CRPL range pattern (e.g., 1-2_3-1, 1-2_3-1A with suffix) - matches after first dash
+      rule(:crpl_range) do
+        (digits >> str("_") >> digits >> dash >> digits >> upper_letter.maybe).as(:crpl_range)
+      end
+
+      # Full report number - support dot-separated parts AND CRPL ranges
+      # ENHANCED: Support multiple dashes for GCR patterns (Session 220)
+      # FIXED: Put GCR pattern first to prioritize matching full dash-separated patterns
+      # FIXED: Add edition.maybe to support revision patterns like 800-53r5 in short format
+      # FIXED: Month abbreviation as edition (e.g., 107-Mar1985, 11-Jan1925)
+      # FIXED: FIPS date format with day and slash (e.g., 11-1-Sep30/1977)
+      rule(:report_number) do
+        first_number >>
+          (
+            # Month abbreviation as edition (e.g., 107-Mar1985, 11-Jan1925)
+            # MUST BE FIRST to catch -MonthYear patterns before they're
+            # incorrectly parsed as other alternatives
+            (dash >> month_abbrev.as(:edition_month) >> digits.as(:edition_year)) |
+            # FIPS date format: -1-Sep30/1977 (part-month-day/year with slash)
+            # Must come before GCR pattern to avoid being matched as multi-dash
+            (dash >> digits.as(:fips_part) >> dash >> month_abbrev.as(:edition_month) >>
+             digits.as(:edition_day) >> slash >> digits.as(:edition_year)) |
+            # Dash with decimal suffix (e.g., 80-2073.3, 123-45.67)
+            # Must come before GCR pattern which expects another dash after second_number
+            (dash >> digits.as(:decimal_base) >> dot >> digits.as(:decimal_suffix)).as(:decimal_number) |
+            # Dash with letter suffix (e.g., 1-1A, 1-3B for NCSTAR, 73-197Ur for IR)
+            # Must come before GCR pattern which expects another dash
+            # Supports U+lowercase letter suffix (e.g., Ur, Ua, Ub-Uj for Unclassified variants)
+            # For other uppercase letters, only match single letter (A, B, C) to avoid consuming revision r
+            (dash >> digits.as(:letter_base) >> (
+              (str("U") >> lower_letter.as(:letter_suffix_extra)) |
+              upper_letter
+            ).as(:letter_suffix)).as(:letter_number) |
+            # Edition dash-year pattern (e.g., -1979 for handbooks like "NBS HB 130-1979")
+            # Matches any 4-digit sequence - the builder decides if it's a year or second_number
+            (dash >> match("[0-9]").repeat(4,
+                                           4).as(:dash_year) >> (space | dot | part | crpl_range | second_number | dash).absent?).as(:edition_dash_year) |
+            # Second number followed by edition dash-year (e.g., -1-1990 for "105-1-1990")
+            # Handles compound numbers with edition year at the end
+            # MUST be BEFORE GCR pattern because both start with dash + second_number + dash
+            (dash >> second_number >> dash >> match("[0-9]").repeat(4,
+                                                                    4).as(:dash_year) >> (space | dot | part | crpl_range | revision | draft).absent?).as(:second_number_edition_year) |
+            # FIPS month+year pattern after part (e.g., -1-Sep1977 for "11-1-Sep1977")
+            (dash >> second_number >> dash >> month_abbrev.as(:edition_month) >> digits.as(:edition_year) >> (space | dot | part | crpl_range | edition | revision | draft).absent?).as(:fips_month_year_after_part) |
+            # GCR multi-dash pattern (e.g., 85-3273-37, 19-200-30B)
+            (dash >> second_number >> dash >> (digits >> upper_letter.maybe).as(:part_number)) |
+            # Dot-separated part (e.g., 984.4 = number 984, part 4)
+            (dot >> second_number) |
+            # Dash-separated with optional revision (e.g., 800-53r5, 1019r1963)
+            (dash >> (crpl_range | second_number) >> edition.maybe) |
+            (dash >> edition)
+            # TODO: Language code suffix without separator (e.g., "1088sp")
+            # Must come AFTER other patterns to avoid consuming them
+            # | (str("sp") | str("pt") | str("es") | match("[a-z]").repeat(2, 4)).as(:language_code) >> (space | dot | part | crpl_range | second_number).absent?) |
+            # Parenthetical language code (e.g., "378(sp)")
+            # | (str("(") >> match("[a-z]").repeat(2, 4).as(:language_code) >> str(")") >> (space | dot | part | crpl_range | second_number).absent?)
+          ).maybe
+      end
+
+      # Volume
+      rule(:volume) do
+        (space.maybe >> (str("v") | str(" Vol. "))) >>
+          (digits >>
+           # Support letter ranges (lowercase normalized in preprocessing)
+           (str("a-l") | str("m-z") | str("A-L") | str("M-Z")).maybe >>
+           # Support single uppercase letters (e.g., v3B, v1A)
+           upper_letter.repeat(0, 2)).as(:volume)
+      end
+
+      # Part - enhanced to support patterns like p1adde1 AND pt3r1 (part with revision)
+      rule(:part) do
+        ((space.maybe >> (str("pt") | str("p") | str("P"))) | str(" Part ")) >>
+          (digits >>
+           # NEW: Revision after part number: pt3r1, p1r1 (space.maybe for preprocessing)
+           (space.maybe >> str("r") >> digits).maybe >>
+           # Existing: Addendum with optional edition: add, adde1
+           (str("add") >> (str("e") >> digits).maybe).maybe >>
+           (dash >> digits).maybe).as(:part)
+      end
+
+      # Revision
+      rule(:revision) do
+        # NEW: Revision with month and year: rJun1992, r Jun1992 - LONGEST MATCH FIRST
+        # Enhanced to support leading space (Session 219)
+        (space.maybe >> (str("r") | str("rev")) >> space.maybe >> month_abbrev.as(:revision_month) >> digits.as(:revision_year)) |
+          # Revision with slash and year: r6/1925, r11/1924 (NEW for LCIRC patterns)
+          (space.maybe >> (str("r") | str("rev")) >> digits.as(:revision) >>
+           slash >> digits.as(:revision_year)) |
+          # Revision with 4-digit year directly: r1995, r 1995 (allow space before year)
+          ((str(" r") | str("r")) >> space.maybe >> match("[0-9]").repeat(4,
+                                                                          4).as(:revision_year)) |
+          # Revision with year: rev2013, rev 2013 (allow space before year)
+          (str("rev") >> space.maybe >> digits.as(:revision_year)) |
+          # Revision with digits AND/OR letters: r1a, r1A, ra, r1
+          # Enhanced to accept letter-only revisions and space before r
+          # ENHANCED: Accept BOTH lowercase and uppercase letters in suffix
+          # ENHANCED: Capture original format prefix for format preservation (e.g., " Rev. 5")
+          ((str(" rev ") | str("rev") | str(" r") | str("r") | str(" Rev. ") | str(" Revision (r)")).as(:revision_prefix) >>
+            ((digits >> match("[a-zA-Z]").maybe) | match("[a-zA-Z]").repeat(1)).as(:revision_id)).as(:revision) |
+          # NEW: Standalone 'r' - MUST BE LAST to avoid consuming from other patterns
+          # Matches " r" at end of input (after preprocessing: "800-56a r", "800-27 r")
+          (str(" r") >> any.absent?).as(:revision_standalone)
+      end
+
+      # Version - V1 SP PARSER COMPATIBLE
+      # Supports: ver1.0.2, ver2, " Ver. 2.0", " Version 1.0", v1.0.2, -v1.0, .ver1.0 (MR format)
+      rule(:version) do
+        # Verbose "ver" form - with or without dots (space.maybe before AND after "ver")
+        # ENHANCED: Accept dot prefix for MR format (e.g., "500-281.ver1.0")
+        ((space | dot).maybe >> str("ver") >> space.maybe >> (digits >> (dot >> digits).repeat).as(:version)) |
+          # Verbose forms with space: " Ver. ", " Version " - require dots
+          ((str(" Ver. ") | str(" Version ")) >>
+            (digits >> dot >> digits >> (dot >> digits).maybe).as(:version)) |
+          # Short form "v" with mandatory dots (v1.0, v1.0.2) - allow optional dash or space before
+          ((dash | space).maybe >> str("v") >> (digits >> dot >> digits >> (dot >> digits).maybe).as(:version))
+      end
+
+      # Update - V1 COMPATIBLE
+      # Format: /Upd{N}-{YYYY}{MM} where MM is optional
+      # Examples: /Upd1-2015, /Upd3-202102, -upd, /upd (after preprocessing)
+      # Update number is optional (e.g., "500-300-upd" has no number)
+      # Captures prefix to preserve original format (-upd vs /Upd)
+      rule(:update) do
+        prefix = (
+          str("/Upd") |
+          (space.maybe >> (str("/upd") | str("-upd")))
+        ).as(:update_prefix)
+
+        prefix >>
+          (
+            digits.as(:update_number).maybe >>
+            (dash >>
+              match("[0-9]").repeat(4, 4).as(:update_year) >>
+              match("[0-9]").repeat(2, 2).as(:update_month).maybe
+            ).maybe
+          ).as(:update)
+      end
+
+      # Addendum
+      rule(:addendum) do
+        ((str("-add") | str(".add") | str(" Add.")) >>
+          (space | dash).maybe >> (digits | str("")).as(:addendum_number)).as(:addendum)
+      end
+
+      # Supplement - enhanced to support date patterns, year patterns, and combined with revision
+      # Examples: suppJan1924, supp3/1926, supp1925, supJun1925-Jun1927 (date ranges), supprev
+      rule(:supplement) do
+        space.maybe >>
+          (str("supp") | str("sup")) >>
+          (
+            # Supplement followed by revision: supprev
+            str("rev").as(:supplement_with_rev) |
+            # Date range pattern: Jan1924-Jan1926
+            (month_abbrev.as(:supp_month_start) >> digits.as(:supp_year_start) >>
+             dash >> month_abbrev.as(:supp_month_end) >> digits.as(:supp_year_end)).as(:supplement_date_range) |
+            # Month and year: Jan1924
+            (month_abbrev.as(:supp_month) >> digits.as(:supp_year)).as(:supplement_date) |
+            # Number with slash and year: 3/1926
+            (digits.as(:supp_number) >> slash >> digits.as(:supp_year)).as(:supplement_slash_year) |
+            # Just year: 1925
+            digits.as(:supp_year) |
+            # General suffix (other patterns)
+            match("[A-Za-z0-9]").repeat(1).as(:supplement_suffix)
+          ).maybe
+      end
+
+      # Errata
+      rule(:errata) do
+        (dash.maybe >> (str("errata") | str("err"))).as(:errata)
+      end
+
+      # Index
+      rule(:index) do
+        (str("index") | str("indx")).as(:index)
+      end
+
+      # Insert
+      rule(:insert) do
+        (str("insert") | str("ins")).as(:insert)
+      end
+
+      # Appendix
+      rule(:appendix) do
+        str("app").as(:appendix)
+      end
+
+      # Section - make digits optional for patterns like just "sec"
+      rule(:section) do
+        str("sec") >> digits.as(:section).maybe
+      end
+
+      # Translation (3-letter language code) - V1 COMPATIBLE
+      # Supports: (spa), " spa", ".spa" (MR format)
+      rule(:translation) do
+        # Parenthetical format: (spa), (por), (ind)
+        (str("(") >> match('\w').repeat(3, 3).as(:translation) >> str(")")) |
+          # Space-prefix format: " spa"
+          (space >> match('\w').repeat(3, 3).as(:translation)) |
+          # Dot-prefix format: ".spa" (machine-readable)
+          (dot >> match('\w').repeat(3, 3).as(:translation))
+      end
+
+      # Public draft suffix - for patterns like 2pd, 3pd
+      rule(:pd_suffix) do
+        (space >> digits >> str("pd")).as(:public_draft)
+      end
+
+      # Draft stage - enhanced to support suffix pattern and number after draft
+      # ENHANCED: Accept optional space before dash to match after report_number
+      rule(:draft) do
+        ((space >> str("(Draft)")) |
+         (space.maybe >> dash >> str("draft") >> ((space >> digits) | digits).maybe) | # Match " -draft 2" OR "-draft2"
+         pd_suffix).as(:draft)
+      end
+
+      # Special date format with slash for FIPS (part of number, not edition)
+      rule(:fips_date) do
+        dash >> digits.as(:fips_part) >> dash >> month_abbrev.as(:fips_month) >>
+          digits.as(:fips_day) >> slash >> digits.as(:fips_year)
+      end
+
+      # All possible parts (order matters!)
+      rule(:parts) do
+        # Put more specific patterns first
+        # CRITICAL: new_stage BEFORE language_code to avoid "ipd" being treated as translation
+        new_stage |
+          section | index | insert | appendix | pd_suffix |
+          edition | date | legacy_edition | revision |
+          version | # MOVED BEFORE volume - try dotted versions (v1.1) before simple volumes (v1)
+          volume | part | update | addendum |
+          supplement | errata | language_code
+      end
+
+      # CIRC Supplement identifier - split into base + supplement
+      # Examples:
+      # - "NBS CIRC 101e2supp" → base="NBS CIRC 101e2", supplement
+      # - "NBS CIRC 25supp-1924" → base="NBS CIRC 25", supplement_year="1924"
+      # - "NBS CIRC 24suppJan1924" → base="NBS CIRC 24", supplement_edition="Jan1924"
+      # - "NBS CIRC suppJun1925-Jun1926" → date range supplement (no base)
+      # - "NBS LCIRC 378Gsup" → base="NBS LCIRC 378G", supplement (no metadata)
+      # - "NBS.LCIRC.378sup1/1927" → dot-separated MR format (after preprocessing)
+      # Dot-separated machine-readable format: NIST.SP.800-116 or #NIST.2024-01-15.123
+      # Enhanced to support parts after number like NIST.SP.1011-I-2.0
+      # Enhanced to support revision+update patterns like NIST.IR.8115r1-upd
+      rule(:mr_identifier) do
+        hash_prefix.maybe >>
+          publisher >> dot >>
+          simple_series >> dot >>
+          report_number >>
+          # Edition with underscore separator (MR format: 1648_2009)
+          (str("_") >> digits.as(:edition_year)).maybe >>
+          # Support letter suffix before update (e.g., 8286C-upd1) - Session 219
+          upper_letter.maybe >>
+          # Support revision component (r1, r5, etc.) before update
+          edition.maybe >>
+          update.maybe >>
+          # Additional dot-separated parts (parts, version, volume, etc.)
+          # MUST come before translation to avoid conflicting with language codes
+          (dot >> (digits | upper_letter)).repeat(0, 3) >>
+          # Language codes at end (.spa, .por, .ind)
+          parts.repeat >> draft.maybe
+      end
+
+      # Main identifier structure
+      # Try compound series first (longest match), then publisher + simple series
+      rule(:identifier) do
+        circ_supplement_identifier |
+          mr_identifier |
+          (
+            # Compound series (includes publisher in series name)
+            compound_series >> (space | dot) >>
+            old_stage.maybe >> # Old style stage after series
+            report_number.maybe >> fips_date.maybe >> parts.repeat >> draft.maybe >> translation.maybe >> new_stage.maybe
+          ) |
+          (
+            # Publisher + simple series - require space/dot between publisher and series
+            publisher >> (space | dot) >>
+            simple_series >>
+            old_stage.maybe >> # Old style stage after series
+            (space | dot) >>
+            report_number.maybe >> fips_date.maybe >> parts.repeat >> draft.maybe >> translation.maybe >> new_stage.maybe
+          ) |
+          (
+            # Simple series only (no publisher)
+            simple_series >>
+            old_stage.maybe >> # Old style stage after series
+            (space | dot) >>
+            report_number.maybe >> fips_date.maybe >> parts.repeat >> draft.maybe >> translation.maybe >> new_stage.maybe
+          )
+      end
+
+      # CIRC Supplement identifier - split into base + supplement
+      # Must be complete rule with all patterns
+      rule(:circ_supplement_identifier) do
+        (
+          (str("NBS CIRC") | str("NBS LCIRC") | str("NBS.CIRC") | str("NBS.LCIRC")).as(:series) >>
+          (space | dot)
+        ).as(:circ_series) >>
+          (
+            # Date range supplement (no base number)
+            (str("supp") >> month_abbrev.as(:supp_month_start) >> digits.as(:supp_year_start) >>
+             dash >> month_abbrev.as(:supp_month_end) >> digits.as(:supp_year_end)).as(:supplement_date_range) |
+            # With base identifier + supplement
+            (
+              # Capture base portion (everything before "supp" or "sup" or slash+year)
+              (
+                # Number with edition: "101e2"
+                (digits.as(:base_number) >> str("e") >> digits.as(:edition_number)) |
+                # Number with revision (for supplement patterns): "145r11"
+                (digits.as(:base_number) >> lower_letter.as(:revision_letter) >> digits.as(:revision_number)) |
+                # Number with letter suffix: "378G"
+                (digits.as(:base_number) >> upper_letter.as(:letter_suffix)) |
+                # Just number: "25", "24"
+                digits.as(:simple_number)
+              ).as(:base_portion) >>
+              # Supplement marker - support both "supp" and "sup", OR implicit supplement via slash+year
+              (
+                # Explicit supplement marker
+                ((str("supp") | str("sup")) >>
+                # Optional supplement metadata
+                (
+                  (month_abbrev >> digits).as(:supplement_month_year) |
+                  # Dash + number + slash + year (e.g., supp-12/1926)
+                  (dash >> digits.as(:supp_number) >> slash >> digits.as(:supp_year)).as(:supplement_dash_slash_year) |
+                  (dash >> digits.as(:supplement_year)) |
+                  (digits.as(:supp_number) >> slash >> digits.as(:supp_year)).as(:supplement_slash_year) |
+                  str("").as(:supplement_empty)
+                ).maybe) |
+                # Implicit supplement via slash+year (e.g., "145r11/1925")
+                (slash >> digits.as(:implicit_supplement_year)).as(:implicit_supplement)
+              )
+            )
+          )
+      end
+
+      root(:identifier)
+    end
+  end
+end