sashite-feen 0.3.0 → 0.5.0

data/lib/sashite/feen/parser/piece_placement.rb

@@ -1,358 +1,469 @@
 # frozen_string_literal: true
 
-require_relative "../error"
-require_relative "../placement"
-
-require "sashite/epin"
+require_relative "../shared/ascii"
+require_relative "../shared/limits"
+require_relative "../errors/piece_placement_error"
 
 module Sashite
   module Feen
     module Parser
-      # Parser for the piece placement field (first field of FEEN).
-      #
-      # Converts a FEEN piece placement string into a Placement object,
-      # decoding board configuration from EPIN notation with:
-      # - Empty square compression (numbers → consecutive nils)
-      # - Multi-dimensional separator preservation (exact "/" counts)
-      # - Support for any irregular board structure
+      # Parser for the FEEN Piece Placement field (Field 1).
       #
-      # The parser preserves the exact separator structure, enabling
-      # perfect round-trip conversion (parse → dump → parse).
+      # Parses into a dimensioned board structure:
+      # - 1D: flat Array of squares
+      # - 2D: Array of rank Arrays
+      # - 3D: Array of layer Arrays of rank Arrays
       #
-      # @see https://sashite.dev/specs/feen/1.0.0/
+      # @api private
       module PiecePlacement
-        # Rank separator character.
-        RANK_SEPARATOR = "/"
-
-        # Pattern to match EPIN pieces (optional state, letter, optional derivation).
-        EPIN_PATTERN = /\A[-+]?[A-Za-z]'?\z/
-
-        # Parse a FEEN piece placement string into a Placement object.
-        #
-        # Supports any valid FEEN structure:
-        # - 1D: Single rank, no separators (e.g., "K2P")
-        # - 2D: Ranks separated by "/" (e.g., "8/8/8")
-        # - 3D+: Ranks separated by multiple "/" (e.g., "5/5//5/5")
-        # - Irregular: Any combination of rank sizes and separators
-        #
-        # @param string [String] FEEN piece placement field string
-        # @return [Placement] Parsed placement object
-        # @raise [Error::Syntax] If placement format is invalid
-        # @raise [Error::Piece] If EPIN notation is invalid
-        #
-        # @example Chess starting position
-        #   parse("+rnbq+kbn+r/+p+p+p+p+p+p+p+p/8/8/8/8/+P+P+P+P+P+P+P+P/+RNBQ+KBN+R")
+        # Parses a Piece Placement field, returning nil on failure.
         #
-        # @example Empty 8x8 board
-        #   parse("8/8/8/8/8/8/8/8")
-        #
-        # @example 1D board
-        #   parse("K2P3k")
-        #
-        # @example Irregular structure
-        #   parse("99999/3///K/k//r")
-        def self.parse(string)
-          # Detect dimension before parsing
-          dimension = detect_dimension(string)
-
-          # Handle 1D case (no separators)
-          if dimension == 1
-            rank = parse_rank(string)
-            return Placement.new([rank], [], 1)
-          end
+        # @param input [String] The Piece Placement field string
+        # @return [Array, nil] Dimensioned board structure or nil
+        def self.safe_parse(input)
+          return nil if input.empty?
 
-          # Parse multi-dimensional structure with separators
-          ranks, separators = parse_with_separators(string)
+          len = input.bytesize
+          return nil if input.getbyte(0) == Ascii::SLASH
+          return nil if input.getbyte(len - 1) == Ascii::SLASH
 
-          Placement.new(ranks, separators, dimension)
+          max_sep = scan_max_separator(input, len)
+          dims = max_sep + 1
+          return nil if dims > Limits::MAX_DIMENSIONS
+
+          case dims
+          when 1 then parse_1d(input, len)
+          when 2 then parse_2d(input, len)
+          when 3 then parse_3d(input, len)
+          end
         end
 
-        # Detect board dimensionality from separator patterns.
-        #
-        # Scans for consecutive "/" characters and returns:
-        #   1 + (maximum consecutive "/" count)
+        # Parses a Piece Placement field, raising on failure.
         #
-        # @param string [String] Piece placement string
-        # @return [Integer] Board dimension (minimum 1)
-        #
-        # @example 1D board (no separators)
-        #   detect_dimension("K2P")  # => 1
-        #
-        # @example 2D board (single "/")
-        #   detect_dimension("8/8")  # => 2
-        #
-        # @example 3D board (contains "//")
-        #   detect_dimension("5/5/5//5/5/5")  # => 3
-        #
-        # @example 4D board (contains "///")
-        #   detect_dimension("2/2///2/2")  # => 4
-        private_class_method def self.detect_dimension(string)
-          return 1 unless string.include?(RANK_SEPARATOR)
+        # @param input [String] The Piece Placement field string
+        # @return [Array] Dimensioned board structure
+        # @raise [PiecePlacementError] If the input is not valid
+        def self.parse(input)
+          result = safe_parse(input)
+          return result unless result.nil?
 
-          max_consecutive = string.scan(%r{/+}).map(&:length).max || 0
-          max_consecutive + 1
+          raise_specific_error!(input)
         end
 
-        # Parse string while preserving exact separators.
-        #
-        # Uses split with capture group to preserve both ranks and separators.
-        # The regex /(\/+)/ captures one or more consecutive "/" characters.
-        #
-        # Result pattern: [rank, separator, rank, separator, ..., rank]
-        # - Even indices (0, 2, 4, ...) are ranks
-        # - Odd indices (1, 3, 5, ...) are separators
-        #
-        # Empty strings are parsed as empty ranks (valid in FEEN).
-        #
-        # @param string [String] Piece placement string
-        # @return [Array<Array<Array>, Array<String>>] [ranks, separators]
-        #
-        # @example Simple split
-        #   parse_with_separators("K/Q/R")
-        #   # => [[[K], [Q], [R]], ["/", "/"]]
-        #
-        # @example Multi-dimensional split
-        #   parse_with_separators("K//Q/R")
-        #   # => [[[K], [Q], [R]], ["//", "/"]]
-        #
-        # @example Trailing separator (empty rank at end)
-        #   parse_with_separators("K///")
-        #   # => [[[K], []], ["///"]]
-        #
-        # @example Leading separator (empty rank at start)
-        #   parse_with_separators("///K")
-        #   # => [[[], [K]], ["///"]]
-        private_class_method def self.parse_with_separators(string)
-          ranks = []
-          separators = []
-
-          # Split with capture group to preserve separators
-          # Use limit=-1 to include trailing empty substrings
-          parts = string.split(%r{(/+)}, -1)
-
-          parts.each_with_index do |part, idx|
-            if idx.even?
-              # Even index = rank content (can be empty string)
-              ranks << parse_rank(part)
-            else
-              # Odd index = separator
-              separators << part
+        class << self
+          private
+
+          # Finds the maximum separator group length in the input.
+          def scan_max_separator(input, len)
+            max = 0
+            cur = 0
+            i = 0
+
+            while i < len
+              if input.getbyte(i) == Ascii::SLASH
+                cur += 1
+              else
+                max = cur if cur > max
+                cur = 0
+              end
+              i += 1
             end
+
+            max = cur if cur > max
+            max
           end
 
-          [ranks, separators]
-        end
+          # Parses a 1D board (no separators).
+          def parse_1d(input, len)
+            squares = parse_segment(input, 0, len)
+            return nil if squares.nil?
+            return nil if squares.size > Limits::MAX_DIMENSION_SIZE
 
-        # Parse a single rank string into an array of pieces and nils.
-        #
-        # Processes rank content character by character:
-        # - Empty string → empty rank (empty array)
-        # - Digits (1-9) start a number → count of empty squares (nils)
-        # - Letters (A-Z, a-z) start EPIN → piece object
-        # - Numbers are parsed greedily (123 = one hundred twenty-three)
-        #
-        # @param rank_str [String] Single rank string (e.g., "rnbqkbnr" or "4p3" or "")
-        # @return [Array] Array containing piece objects and nils (empty if rank_str is empty)
-        # @raise [Error::Syntax] If rank format is invalid
-        # @raise [Error::Piece] If EPIN notation is invalid
-        #
-        # @example Empty rank
-        #   parse_rank("")
-        #   # => []
-        #
-        # @example Rank with only pieces
-        #   parse_rank("rnbqkbnr")
-        #   # => [r, n, b, q, k, b, n, r]
-        #
-        # @example Rank with empty squares
-        #   parse_rank("4p3")
-        #   # => [nil, nil, nil, nil, p, nil, nil, nil]
-        #
-        # @example Rank with large empty count
-        #   parse_rank("100")
-        #   # => [nil, nil, ..., nil] (100 nils)
-        #
-        # @example Mixed rank
-        #   parse_rank("+K2+Q")
-        #   # => [+K, nil, nil, +Q]
-        private_class_method def self.parse_rank(rank_str)
-          # Handle empty rank (valid in FEEN)
-          return [] if rank_str.empty?
-
-          result = []
-          chars = rank_str.chars
-          i = 0
-
-          while i < chars.size
-            char = chars[i]
-
-            if digit?(char)
-              # Parse complete number (greedy)
-              num_str, consumed = extract_number(chars, i)
-              count = num_str.to_i
-
-              validate_empty_count!(count, num_str)
-
-              # Add empty squares
-              count.times { result << nil }
-              i += consumed
-            else
-              # Parse EPIN piece notation
-              piece_str, consumed = extract_epin(chars, i)
-              piece = parse_piece(piece_str)
-              result << piece
-              i += consumed
+            squares
+          end
+
+          # Parses a 2D board (ranks separated by "/").
+          # Scans for "/" byte positions and parses segments by range.
+          def parse_2d(input, len)
+            ranks = []
+            seg_start = 0
+            i = 0
+
+            while i <= len
+              if i == len || input.getbyte(i) == Ascii::SLASH
+                squares = parse_segment(input, seg_start, i)
+                return nil if squares.nil?
+                return nil if squares.size > Limits::MAX_DIMENSION_SIZE
+
+                ranks << squares
+                seg_start = i + 1
+              end
+              i += 1
             end
+
+            return nil if ranks.size > Limits::MAX_DIMENSION_SIZE
+
+            ranks
           end
 
-          result
-        end
+          # Parses a 3D board in a single scan.
+          # Detects "//" layer boundaries and "/" rank boundaries.
+          def parse_3d(input, len)
+            layers = []
+            ranks = []
+            seg_start = 0
+            ranks_per_layer = nil
+            i = 0
+
+            while i < len
+              if input.getbyte(i) == Ascii::SLASH
+                # Parse the pending segment
+                squares = parse_segment(input, seg_start, i)
+                return nil if squares.nil?
+                return nil if squares.size > Limits::MAX_DIMENSION_SIZE
+
+                ranks << squares
+
+                # Check for "//" (layer boundary)
+                if (i + 1) < len && input.getbyte(i + 1) == Ascii::SLASH
+                  # Dimensional coherence: each layer must have >= 2 ranks
+                  return nil if ranks.size < 2
+
+                  if ranks_per_layer.nil?
+                    ranks_per_layer = ranks.size
+                    return nil if ranks_per_layer > Limits::MAX_DIMENSION_SIZE
+                  else
+                    return nil unless ranks.size == ranks_per_layer
+                  end
+
+                  layers << ranks
+                  ranks = []
+                  seg_start = i + 2
+                  i += 2
+                else
+                  seg_start = i + 1
+                  i += 1
+                end
+              else
+                i += 1
+              end
+            end
 
-        # Check if character is a digit (1-9 for starting digit).
-        #
-        # Note: Leading zero not allowed in FEEN numbers.
-        #
-        # @param char [String] Single character
-        # @return [Boolean] True if character is 1-9
-        private_class_method def self.digit?(char)
-          char >= "1" && char <= "9"
-        end
+            # Last segment + last layer
+            squares = parse_segment(input, seg_start, len)
+            return nil if squares.nil?
+            return nil if squares.size > Limits::MAX_DIMENSION_SIZE
 
-        # Extract a complete number from character array (greedy parsing).
-        #
-        # Reads all consecutive digits starting from start_index.
-        # First digit must be 1-9, subsequent digits can be 0-9.
-        #
-        # @param chars [Array<String>] Array of characters
-        # @param start_index [Integer] Starting index
-        # @return [Array(String, Integer)] Number string and characters consumed
-        #
-        # @example Single digit
-        #   extract_number(['8', 'K'], 0)  # => ["8", 1]
-        #
-        # @example Multi-digit
-        #   extract_number(['1', '2', '3', 'K'], 0)  # => ["123", 3]
-        #
-        # @example Large number
-        #   extract_number(['9', '9', '9', '9', '9'], 0)  # => ["99999", 5]
-        private_class_method def self.extract_number(chars, start_index)
-          num_str = chars[start_index]
-          i = start_index + 1
-
-          # Continue reading digits (including 0)
-          while i < chars.size && chars[i] >= "0" && chars[i] <= "9"
-            num_str += chars[i]
-            i += 1
+            ranks << squares
+
+            return nil if ranks.size < 2
+
+            if ranks_per_layer.nil?
+              ranks_per_layer = ranks.size
+              return nil if ranks_per_layer > Limits::MAX_DIMENSION_SIZE
+            else
+              return nil unless ranks.size == ranks_per_layer
+            end
+
+            layers << ranks
+            return nil if layers.size > Limits::MAX_DIMENSION_SIZE
+
+            layers
           end
 
-          consumed = i - start_index
-          [num_str, consumed]
-        end
+          # Parses a single segment (rank) by byte range [seg_start, seg_stop).
+          # Returns Array of (String | nil) or nil on failure.
+          # Inlines EPIN validation and integer conversion.
+          def parse_segment(input, seg_start, seg_stop)
+            return nil if seg_start >= seg_stop
+
+            squares = []
+            pos = seg_start
+            last_was_empty = false
+
+            while pos < seg_stop
+              byte = input.getbyte(pos)
+
+              if byte >= Ascii::ZERO && byte <= Ascii::NINE
+                # Empty count token
+                return nil if last_was_empty
+
+                count_start = pos
+                pos += 1
+                while pos < seg_stop
+                  b = input.getbyte(pos)
+                  break unless b >= Ascii::ZERO && b <= Ascii::NINE
+
+                  pos += 1
+                end
+
+                # Leading zeros forbidden
+                return nil if (pos - count_start) > 1 && input.getbyte(count_start) == Ascii::ZERO
+
+                # Inline integer conversion (avoids byteslice + to_i)
+                count = 0
+                j = count_start
+                while j < pos
+                  count = count * 10 + (input.getbyte(j) - Ascii::ZERO)
+                  j += 1
+                end
+
+                return nil if count < 1
+
+                count.times { squares << nil }
+                last_was_empty = true
+              else
+                # EPIN token — inline validation: [+-]?[A-Za-z]^?'?
+                piece_start = pos
+
+                # Optional state modifier
+                if byte == Ascii::MINUS || byte == Ascii::PLUS
+                  pos += 1
+                  return nil if pos >= seg_stop
+
+                  byte = input.getbyte(pos)
+                end
+
+                # Required letter (bit trick)
+                lowered = byte | 0x20
+                return nil if lowered < Ascii::LOWER_A || lowered > Ascii::LOWER_Z
+
+                pos += 1
+
+                # Optional terminal ^ then optional derivation '
+                if pos < seg_stop
+                  byte = input.getbyte(pos)
+
+                  if byte == Ascii::CARET
+                    pos += 1
+
+                    if pos < seg_stop && input.getbyte(pos) == Ascii::APOSTROPHE
+                      pos += 1
+                    end
+                  elsif byte == Ascii::APOSTROPHE
+                    pos += 1
+                  end
+                end
+
+                squares << input.byteslice(piece_start, pos - piece_start)
+                last_was_empty = false
+              end
+            end
 
-        # Validate empty square count.
-        #
-        # Count must be at least 1 (FEEN doesn't allow "0" for zero squares).
-        #
-        # @param count [Integer] Parsed count value
-        # @param count_str [String] Original string for error message
-        # @raise [Error::Syntax] If count is less than 1
-        private_class_method def self.validate_empty_count!(count, count_str)
-          return if count >= 1
-
-          raise ::Sashite::Feen::Error::Syntax,
-                "Empty square count must be at least 1, got #{count_str}"
-        end
+            squares
+          end
 
-        # Extract EPIN notation from character array.
-        #
-        # EPIN format: [state][letter][derivation]
-        # - state: optional "+" or "-" prefix
-        # - letter: required A-Z or a-z
-        # - derivation: optional "'" suffix
-        #
-        # @param chars [Array<String>] Array of characters
-        # @param start_index [Integer] Starting index
-        # @return [Array(String, Integer)] EPIN string and characters consumed
-        # @raise [Error::Syntax] If EPIN format is incomplete or invalid
-        #
-        # @example Simple piece
-        #   extract_epin(['K', 'Q'], 0)  # => ["K", 1]
-        #
-        # @example Enhanced piece
-        #   extract_epin(['+', 'R', 'B'], 0)  # => ["+R", 2]
-        #
-        # @example Foreign piece
-        #   extract_epin(['K', "'", 'Q'], 0)  # => ["K'", 2]
-        #
-        # @example Complex piece
-        #   extract_epin(['-', 'p', "'", 'K'], 0)  # => ["-p'", 3]
-        private_class_method def self.extract_epin(chars, start_index)
-          i = start_index
-          piece_chars = []
-
-          # Optional state prefix (+ or -)
-          if i < chars.size && ["+", "-"].include?(chars[i])
-            piece_chars << chars[i]
-            i += 1
+          # ----------------------------------------------------------------
+          # Error path (cold): re-validates for specific error messages
+          # ----------------------------------------------------------------
+
+          def raise_specific_error!(input)
+            if input.empty?
+              raise PiecePlacementError, PiecePlacementError::EMPTY
+            end
+
+            if input.getbyte(0) == Ascii::SLASH
+              raise PiecePlacementError, PiecePlacementError::STARTS_WITH_SEPARATOR
+            end
+
+            if input.getbyte(input.bytesize - 1) == Ascii::SLASH
+              raise PiecePlacementError, PiecePlacementError::ENDS_WITH_SEPARATOR
+            end
+
+            len = input.bytesize
+            max_sep = scan_max_separator(input, len)
+            dims = max_sep + 1
+
+            if dims > Limits::MAX_DIMENSIONS
+              raise PiecePlacementError, PiecePlacementError::EXCEEDS_MAX_DIMENSIONS
+            end
+
+            case dims
+            when 1 then raise_1d_errors!(input, len)
+            when 2 then raise_2d_errors!(input, len)
+            when 3 then raise_3d_errors!(input, len)
+            end
           end
 
-          # Base letter (required)
-          if i >= chars.size || !letter?(chars[i])
-            raise ::Sashite::Feen::Error::Syntax,
-                  "Expected letter in EPIN notation at position #{start_index}"
+          def raise_1d_errors!(input, len)
+            squares = raise_parse_segment!(input, 0, len)
+            raise_dimension_size!(squares.size)
           end
 
-          piece_chars << chars[i]
-          i += 1
+          def raise_2d_errors!(input, len)
+            seg_start = 0
+            rank_count = 0
+            i = 0
+
+            while i <= len
+              if i == len || input.getbyte(i) == Ascii::SLASH
+                squares = raise_parse_segment!(input, seg_start, i)
+                raise_dimension_size!(squares.size)
+                rank_count += 1
+                seg_start = i + 1
+              end
+              i += 1
+            end
 
-          # Optional derivation suffix (')
-          if i < chars.size && chars[i] == "'"
-            piece_chars << chars[i]
-            i += 1
+            raise_dimension_size!(rank_count)
           end
 
-          piece_str = piece_chars.join
-          consumed = i - start_index
+          def raise_3d_errors!(input, len)
+            ranks_in_layer = 0
+            ranks_per_layer = nil
+            layer_count = 0
+            seg_start = 0
+            i = 0
+
+            while i < len
+              if input.getbyte(i) == Ascii::SLASH
+                squares = raise_parse_segment!(input, seg_start, i)
+                raise_dimension_size!(squares.size)
+                ranks_in_layer += 1
+
+                if (i + 1) < len && input.getbyte(i + 1) == Ascii::SLASH
+                  if ranks_in_layer < 2
+                    raise PiecePlacementError, PiecePlacementError::DIMENSIONAL_COHERENCE
+                  end
+
+                  if ranks_per_layer.nil?
+                    ranks_per_layer = ranks_in_layer
+                    raise_dimension_size!(ranks_per_layer)
+                  elsif ranks_in_layer != ranks_per_layer
+                    raise PiecePlacementError, PiecePlacementError::DIMENSIONAL_COHERENCE
+                  end
+
+                  layer_count += 1
+                  ranks_in_layer = 0
+                  seg_start = i + 2
+                  i += 2
+                else
+                  seg_start = i + 1
+                  i += 1
+                end
+              else
+                i += 1
+              end
+            end
 
-          [piece_str, consumed]
-        end
+            # Last segment + last layer
+            squares = raise_parse_segment!(input, seg_start, len)
+            raise_dimension_size!(squares.size)
+            ranks_in_layer += 1
 
-        # Check if character is a letter.
-        #
-        # @param char [String] Single character
-        # @return [Boolean] True if character is A-Z or a-z
-        private_class_method def self.letter?(char)
-          (char >= "A" && char <= "Z") || (char >= "a" && char <= "z")
-        end
+            if ranks_in_layer < 2
+              raise PiecePlacementError, PiecePlacementError::DIMENSIONAL_COHERENCE
+            end
 
-        # Parse EPIN string into a piece identifier object.
-        #
-        # Delegates to Sashite::Epin for actual parsing and validation.
-        #
-        # @param epin_str [String] EPIN notation string
-        # @return [Object] Piece identifier object (Epin::Identifier)
-        # @raise [Error::Piece] If EPIN is invalid or parsing fails
-        #
-        # @example Valid pieces
-        #   parse_piece("K")     # => Epin::Identifier (King)
-        #   parse_piece("+R")    # => Epin::Identifier (Enhanced Rook)
-        #   parse_piece("-p'")   # => Epin::Identifier (Diminished foreign pawn)
-        #
-        # @example Invalid piece
-        #   parse_piece("X#")    # => raises Error::Piece
-        private_class_method def self.parse_piece(epin_str)
-          # Pre-validate format
-          unless EPIN_PATTERN.match?(epin_str)
-            raise ::Sashite::Feen::Error::Piece,
-                  "Invalid EPIN notation: #{epin_str}"
+            if ranks_per_layer && ranks_in_layer != ranks_per_layer
+              raise PiecePlacementError, PiecePlacementError::DIMENSIONAL_COHERENCE
+            end
+
+            layer_count += 1
+            raise_dimension_size!(layer_count)
+          end
+
+          # Parses a segment on the error path, raising specific errors.
+          def raise_parse_segment!(input, seg_start, seg_stop)
+            if seg_start >= seg_stop
+              raise PiecePlacementError, PiecePlacementError::EMPTY_SEGMENT
+            end
+
+            squares = []
+            pos = seg_start
+            last_was_empty = false
+
+            while pos < seg_stop
+              byte = input.getbyte(pos)
+
+              if byte >= Ascii::ZERO && byte <= Ascii::NINE
+                if last_was_empty
+                  raise PiecePlacementError, PiecePlacementError::CONSECUTIVE_EMPTY_COUNTS
+                end
+
+                count_start = pos
+                pos += 1
+                while pos < seg_stop
+                  b = input.getbyte(pos)
+                  break unless b >= Ascii::ZERO && b <= Ascii::NINE
+
+                  pos += 1
+                end
+
+                if (pos - count_start) > 1 && input.getbyte(count_start) == Ascii::ZERO
+                  raise PiecePlacementError, PiecePlacementError::INVALID_EMPTY_COUNT
+                end
+
+                count = 0
+                j = count_start
+                while j < pos
+                  count = count * 10 + (input.getbyte(j) - Ascii::ZERO)
+                  j += 1
+                end
+
+                if count < 1
+                  raise PiecePlacementError, PiecePlacementError::INVALID_EMPTY_COUNT
+                end
+
+                count.times { squares << nil }
+                last_was_empty = true
+              else
+                piece_start = pos
+
+                if byte == Ascii::MINUS || byte == Ascii::PLUS
+                  pos += 1
+                  byte = pos < seg_stop ? input.getbyte(pos) : nil
+                end
+
+                valid_letter = byte && (byte | 0x20) >= Ascii::LOWER_A && (byte | 0x20) <= Ascii::LOWER_Z
+
+                if valid_letter
+                  pos += 1
+                  if pos < seg_stop
+                    byte = input.getbyte(pos)
+                    if byte == Ascii::CARET
+                      pos += 1
+                      if pos < seg_stop && input.getbyte(pos) == Ascii::APOSTROPHE
+                        pos += 1
+                      end
+                    elsif byte == Ascii::APOSTROPHE
+                      pos += 1
+                    end
+                  end
+                end
+
+                unless valid_letter && (pos - piece_start) >= 1
+                  raise PiecePlacementError, PiecePlacementError::INVALID_PIECE_TOKEN
+                end
+
+                squares << input.byteslice(piece_start, pos - piece_start)
+                last_was_empty = false
+              end
+            end
+
+            squares
           end
 
-          # Parse using EPIN library
-          ::Sashite::Epin.parse(epin_str)
-        rescue ::StandardError => e
-          raise ::Sashite::Feen::Error::Piece,
-                "Failed to parse EPIN '#{epin_str}': #{e.message}"
+          def raise_dimension_size!(size)
+            return if size <= Limits::MAX_DIMENSION_SIZE
+
+            raise PiecePlacementError, PiecePlacementError::DIMENSION_SIZE_EXCEEDED
+          end
         end
+
+        private_class_method :scan_max_separator,
+                             :parse_1d,
+                             :parse_2d,
+                             :parse_3d,
+                             :parse_segment,
+                             :raise_specific_error!,
+                             :raise_1d_errors!,
+                             :raise_2d_errors!,
+                             :raise_3d_errors!,
+                             :raise_parse_segment!,
+                             :raise_dimension_size!
+
+        freeze
       end
     end
   end