janeway-jsonpath 0.6.0 → 1.1.0

data/lib/janeway/interpreters/function_interpreter.rb

@@ -22,6 +22,10 @@ module Janeway
       def initialize(function)
         super
         @params = function.parameters.map { |param| TreeConstructor.ast_node_to_interpreter(param) }
+        # Build the function body from the registry. This is the point at
+        # which per-instance specialization happens — e.g. match/search
+        # compile a literal regex once, capturing it in the closure.
+        @body = Functions::REGISTRY.fetch(function.name)[:build].call(function.parameters)
       end
 
       # @param input [Array, Hash] the results of processing so far
@@ -30,7 +34,7 @@ module Janeway
       # @param _path [Array<String>] elements of normalized path to the current input
       def interpret(input, _parent, root, _path)
         params = interpret_function_parameters(@params, input, root)
-        function.body.call(*params)
+        @body.call(*params)
       end
 
       # Evaluate the expressions in the parameter list to make the parameter values

data/lib/janeway/interpreters/index_selector_delete_if.rb

@@ -28,6 +28,7 @@ module Janeway
 
         index = selector.value
         result = input.fetch(index) # raises IndexError if no such index
+        index += input.size if index.negative? # yield positive index for the normalize path
         return unless @yield_proc.call(input[index], input, path + [index])
 
         input.delete_at(index) # returns nil if deleted value is nil, or if no value was deleted

data/lib/janeway/interpreters/index_selector_interpreter.rb

@@ -31,7 +31,9 @@ module Janeway
         result = input.fetch(selector.value) # raises IndexError if no such index
         return [result] unless @next
 
-        @next.interpret(result, input, root, path + [selector.value])
+        index = selector.value
+        index += input.size if index.negative?
+        @next.interpret(result, input, root, path + [index])
       rescue IndexError
         []
       end

data/lib/janeway/interpreters/iteration_helper.rb

@@ -6,21 +6,28 @@ module Janeway
   module Interpreters
     # Mixin for interpreter classes that yield to a block
     module IterationHelper
+      # Sentinel block used by Interpreter#make_deleter to turn a DeleteIf
+      # into an unconditional deleter. `equal?`-comparable so future fast
+      # paths (bulk clear) can detect it.
+      PASS_ALL = proc { true }.freeze
       # Returns a Proc that yields the correct number of parameters to a block
       #
       # block.arity is -1 when no block is given, and an enumerator is being returned
       # @return [Proc] which takes 3 parameters
       def make_yield_proc(&block)
+        # Bind the block locally so the returned proc captures a local, not the
+        # containing instance's @block ivar (avoids an ivar read per yield).
+        b = block
         if block.arity.negative?
           # Yield just the value to an enumerator, to enable instance method calls on
           # matched values like this: enum.delete_if(&:even?)
-          proc { |value, _parent, _path| @block.call(value) }
+          proc { |value, _parent, _path| b.call(value) }
         elsif block.arity > 3
           # Only do the work of constructing the normalized path when it is actually used
-          proc { |value, parent, path| @block.call(value, parent, path.last, normalized_path(path)) }
+          proc { |value, parent, path| b.call(value, parent, path.last, normalized_path(path)) }
         else
           # block arity is 1, 2 or 3. Send all 3 parameters regardless.
-          proc { |value, parent, path| @block.call(value, parent, path.last) }
+          proc { |value, parent, path| b.call(value, parent, path.last) }
         end
       end
 
@@ -37,8 +44,15 @@ module Janeway
       def normalized_path(components)
         # First component is the root identifer, the remaining components are
         # all index selectors or name selectors.
-        # Handle the root identifier separately, because .normalize does not handle those.
-        '$' + components[1..].map { NormalizedPath.normalize(_1) }.join
+        # Build the result string in a single pass — avoids `components[1..]`
+        # (slice allocation) plus `.map { ... }.join` (intermediate Array).
+        result = +'$'
+        i = 1
+        while i < components.size
+          result << NormalizedPath.normalize(components[i])
+          i += 1
+        end
+        result
       end
     end
   end

data/lib/janeway/interpreters/root_node_delete_if.rb

@@ -1,33 +1,74 @@
 # frozen_string_literal: true
 
 require_relative 'root_node_interpreter'
+require_relative 'iteration_helper'
 
 module Janeway
   module Interpreters
-    # Interprets the root node for deletion
-    class RootNodeDeleter < RootNodeInterpreter
-      # Delete all values from the root node.
-      #
-      # TODO: unclear, for deletion is there a difference between queries '$' and '$.*'?
+    # Delete values from the root node for which the block returns a truthy value.
+    class RootNodeDeleteIf < RootNodeInterpreter
+      include IterationHelper
+
+      # @param node [AST::RootNode]
+      def initialize(node, &block)
+        super(node)
+        @block = block
+
+        # Make a proc that yields the correct number of values to a block
+        @yield_proc = make_yield_proc(&block)
+      end
+
+      # Delete values from the root container for which the block returns truthy.
       #
       # @param _input [Array, Hash] the results of processing so far
       # @param _parent [Array, Hash] parent of the input object
       # @param root [Array, Hash] the entire input
       # @param _path [Array<String>] elements of normalized path to the current input
       # @return [Array] deleted elements
-      def interpret(_input, _parent, root, _path)
+      def interpret(_input, _parent, root, _path = nil)
         case root
-        when Array
-          results = root.dup
-          root.clear
-          results
-        when Hash
-          results = root.values
-          root.clear
-          results
-        else
-          []
+        when Array then maybe_delete_array_values(root)
+        when Hash then maybe_delete_hash_values(root)
+        else []
+        end
+      end
+
+      private
+
+      # @param input [Array]
+      def maybe_delete_array_values(input)
+        # Fast path: unconditional delete (from Interpreter#make_deleter).
+        if @block.equal?(IterationHelper::PASS_ALL)
+          results = input.dup
+          input.clear
+          return results
+        end
+
+        results = []
+        (input.size - 1).downto(0).each do |i|
+          next unless @yield_proc.call(input[i], input, ['$', i])
+
+          results << input.delete_at(i)
+        end
+        results.reverse
+      end
+
+      # @param input [Hash]
+      def maybe_delete_hash_values(input)
+        # Fast path: unconditional delete (from Interpreter#make_deleter).
+        if @block.equal?(IterationHelper::PASS_ALL)
+          results = input.values
+          input.clear
+          return results
+        end
+
+        results = []
+        input.each do |key, value|
+          next unless @yield_proc.call(value, input, ['$', key])
+
+          results << input.delete(key)
         end
+        results
       end
     end
   end

data/lib/janeway/interpreters/tree_constructor.rb

@@ -44,26 +44,6 @@ module Janeway
         end
       end
 
-      # Return a Deleter interpreter for the given AST node.
-      # This interpreter deletes matched values.
-      #
-      # @param expr [AST::Expression]
-      # @return [Interprteters::Base]
-      def self.ast_node_to_deleter(expr)
-        case expr
-        when AST::IndexSelector then IndexSelectorDeleter.new(expr)
-        when AST::ArraySliceSelector then ArraySliceSelectorDeleter.new(expr)
-        when AST::NameSelector then NameSelectorDeleter.new(expr)
-        when AST::FilterSelector then FilterSelectorDeleter.new(expr)
-        when AST::WildcardSelector then WildcardSelectorDeleter.new(expr)
-        when AST::ChildSegment then ChildSegmentDeleter.new(expr)
-        when AST::RootNode then RootNodeDeleter.new(expr)
-        when nil then nil # caller has no @next node
-        else
-          raise "Unknown AST expression: #{expr.inspect}"
-        end
-      end
-
       # Return a DeleteIf interpreter for the given AST node.
       # This interpreter deletes matched values, but only after
       # yielding to a block that returns a truthy value.

data/lib/janeway/interpreters/wildcard_selector_delete_if.rb

@@ -36,6 +36,15 @@ module Janeway
       # @param input [Array]
       # @param path [Array]
       def maybe_delete_array_values(input, path)
+        # Fast path: unconditional delete (from Interpreter#make_deleter).
+        # Bulk clear is O(n) with much smaller constants than reverse-iterate
+        # + delete_at + per-element proc call.
+        if @block.equal?(IterationHelper::PASS_ALL)
+          results = input.dup
+          input.clear
+          return results
+        end
+
         results = []
         (input.size - 1).downto(0).each do |i|
           next unless @yield_proc.yield(input[i], input, path + [i])
@@ -48,6 +57,13 @@ module Janeway
       # @param input [Hash]
       # @param path [Array]
       def maybe_delete_hash_values(input, path)
+        # Fast path: unconditional delete (from Interpreter#make_deleter).
+        if @block.equal?(IterationHelper::PASS_ALL)
+          results = input.values
+          input.clear
+          return results
+        end
+
         results = []
         input.each do |key, value|
           next unless @yield_proc.yield(value, input, path + [key])

data/lib/janeway/interpreters/yielder.rb

@@ -19,6 +19,12 @@ module Janeway
         @yield_proc = make_yield_proc(&block)
       end
 
+      # Frozen empty array — Yielder is only used by Enumerator#each and
+      # #find_paths, both of which discard the traversal's return value
+      # (results are surfaced via yield instead). Returning a shared frozen
+      # array avoids allocating a wrapper array per leaf.
+      EMPTY_RESULT = [].freeze
+
       # Yield each input value
       #
       # @param input [Array, Hash] the results of processing so far
@@ -26,10 +32,10 @@ module Janeway
       # @param _root [Array, Hash] the entire input
       # @param path [Array<String, Integer>] components of normalized path to the current input
       # @yieldparam [Object] matched value
-      # @return [Object] input as node list
+      # @return [Array] frozen empty array — see EMPTY_RESULT
       def interpret(input, parent, _root, path)
         @yield_proc.call(input, parent, path)
-        input.is_a?(Array) ? input : [input]
+        EMPTY_RESULT
       end
 
       # Dummy method from Interpreters::Base, allow child segment interpreter to disable the

data/lib/janeway/lexer.rb

@@ -38,9 +38,23 @@ module Janeway
     TWO_CHAR_LEX_FIRST = TWO_CHAR_LEX.map { |lexeme| lexeme[0] }.freeze
     ONE_OR_TWO_CHAR_LEX = ONE_CHAR_LEX & TWO_CHAR_LEX.map { |str| str[0] }.freeze
 
+    # O(1)-lookup companions to the arrays above. Hash#include? and the reverse
+    # lookup avoid the linear scan that .include? / .key would do per token.
+    LEXEME_TO_TYPE = OPERATORS.invert.freeze
+    ONE_CHAR_LEX_SET = ONE_CHAR_LEX.each_with_object({}) { |c, h| h[c] = true }.freeze
+    TWO_CHAR_LEX_SET = TWO_CHAR_LEX.each_with_object({}) { |c, h| h[c] = true }.freeze
+    TWO_CHAR_LEX_FIRST_SET = TWO_CHAR_LEX_FIRST.each_with_object({}) { |c, h| h[c] = true }.freeze
+    ONE_OR_TWO_CHAR_LEX_SET = ONE_OR_TWO_CHAR_LEX.each_with_object({}) { |c, h| h[c] = true }.freeze
+
     WHITESPACE = " \t\n\r"
     KEYWORD = %w[true false null].freeze
+    KEYWORD_SET = KEYWORD.each_with_object({}) { |k, h| h[k] = true }.freeze
     FUNCTIONS = %w[length count match search value].freeze
+    FUNCTIONS_SET = FUNCTIONS.each_with_object({}) { |k, h| h[k] = true }.freeze
+
+    # Hoisted from lex_delimited_string. Given a delimiter, the value is the "other" delimiter.
+    OTHER_DELIMITER = { "'" => '"', '"' => "'" }.freeze
+    QUOTE_LEX_SET = { "'" => true, '"' => true }.freeze
 
     # faster to check membership in a string than an array of char (benchmarked ruby 3.1.2)
     ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
@@ -72,6 +86,7 @@ module Janeway
     end
 
     def start_tokenization
+      raise err('JSONPath query is empty') if @source.empty?
       if WHITESPACE.include?(@source[0]) || WHITESPACE.include?(@source[-1])
         raise err('JSONPath query may not start or end with whitespace')
       end
@@ -88,18 +103,18 @@ module Janeway
       return if WHITESPACE.include?(c)
 
       token =
-        if ONE_OR_TWO_CHAR_LEX.include?(c)
+        if ONE_OR_TWO_CHAR_LEX_SET.include?(c)
           token_from_one_or_two_char_lex(c)
-        elsif ONE_CHAR_LEX.include?(c)
+        elsif ONE_CHAR_LEX_SET.include?(c)
           token_from_one_char_lex(c)
-        elsif TWO_CHAR_LEX_FIRST.include?(c)
+        elsif TWO_CHAR_LEX_FIRST_SET.include?(c)
           token_from_two_char_lex(c)
-        elsif %w[" '].include?(c)
+        elsif QUOTE_LEX_SET.include?(c)
           lex_delimited_string(c)
         elsif digit?(c)
           lex_number
         elsif name_first_char?(c)
-          lex_member_name_shorthand(ignore_keywords: tokens.last&.type == :dot)
+          lex_member_name_shorthand(ignore_keywords: previous_token_type == :dot)
         end
       raise err("Unknown character: #{c.inspect}") unless token
 
@@ -126,20 +141,20 @@ module Janeway
         raise err("Operator #{lexeme.inspect} must not be followed by whitespace")
       end
 
-      Token.new(OPERATORS.key(lexeme), lexeme, nil, current_location)
+      Token.new(LEXEME_TO_TYPE[lexeme], lexeme, nil, current_location)
     end
 
     # Consumes an operator that could be either 1 or 2 chars in length
     # @return [Token]
     def token_from_one_or_two_char_lex(lexeme)
-      next_two_chars = [lexeme, lookahead].join
-      if TWO_CHAR_LEX.include?(next_two_chars)
+      next_two_chars = lexeme + lookahead
+      if TWO_CHAR_LEX_SET.include?(next_two_chars)
         consume
         if next_two_chars == '..' && WHITESPACE.include?(lookahead)
           raise err("Operator #{next_two_chars.inspect} must not be followed by whitespace")
         end
 
-        Token.new(OPERATORS.key(next_two_chars), next_two_chars, nil, current_location)
+        Token.new(LEXEME_TO_TYPE[next_two_chars], next_two_chars, nil, current_location)
       else
         token_from_one_char_lex(lexeme)
       end
@@ -148,11 +163,11 @@ module Janeway
     # Consumes a 2 char operator
     # @return [Token]
     def token_from_two_char_lex(lexeme)
-      next_two_chars = [lexeme, lookahead].join
-      raise err("Unknown operator \"#{lexeme}\"") unless TWO_CHAR_LEX.include?(next_two_chars)
+      next_two_chars = lexeme + lookahead
+      raise err("Unknown operator \"#{lexeme}\"") unless TWO_CHAR_LEX_SET.include?(next_two_chars)
 
       consume
-      Token.new(OPERATORS.key(next_two_chars), next_two_chars, nil, current_location)
+      Token.new(LEXEME_TO_TYPE[next_two_chars], next_two_chars, nil, current_location)
     end
 
     def consume
@@ -165,12 +180,24 @@ module Janeway
       consume while digit?(lookahead)
     end
 
+    # @return [String] source substring for the lexeme currently being built
+    def current_lexeme
+      source[lexeme_start_p..(next_p - 1)]
+    end
+
+    # Type of the most-recently-emitted token, or nil if none.
+    # Named lookback for the two context-sensitive lexing decisions
+    # (identifier-in-brackets rejection; keyword ignore after `.`).
+    # @return [Symbol, nil]
+    def previous_token_type
+      @tokens.last&.type
+    end
+
     # @param delimiter [String] eg. ' or "
     # @return [Token] string token
     def lex_delimited_string(delimiter)
-      allowed_delimiters = %w[' "]
       # the "other" delimiter char, which is not currently being treated as a delimiter
-      non_delimiter = allowed_delimiters.reject { |char| char == delimiter }.first
+      non_delimiter = OTHER_DELIMITER[delimiter]
 
       literal_chars = []
       while lookahead != delimiter && source_uncompleted?
@@ -189,7 +216,7 @@ module Janeway
             end
           elsif unescaped?(next_char)
             consume
-          elsif allowed_delimiters.include?(next_char) && next_char != delimiter
+          elsif QUOTE_LEX_SET.include?(next_char) && next_char != delimiter
             consume
           else
             raise err("invalid character #{next_char.inspect}")
@@ -203,7 +230,7 @@ module Janeway
       literal = literal_chars.join
 
       # lexeme value includes delimiters and literal escape characters
-      lexeme = source[lexeme_start_p..(next_p - 1)]
+      lexeme = current_lexeme
 
       Token.new(:string, lexeme, literal, current_location)
     end
@@ -284,10 +311,11 @@ module Janeway
     # @param low_surrogate_hex [String] string of hex digits, eg. "DE09"
     # @return [String] UTF-8 string containing a single multi-byte unicode character, eg. "😉"
     def convert_surrogate_pair_to_codepoint(high_surrogate_hex, low_surrogate_hex)
-      [high_surrogate_hex, low_surrogate_hex].each do |hex_str|
-        raise ArgumentError, "expect 4 hex digits, got #{hex_string.inspect}" unless hex_str.size == 4
-      end
-
+      # Callers guarantee 4-char inputs (consume_four_hex_digits followed by
+      # high_surrogate?/low_surrogate? which pre-check size). The old defensive
+      # guard here referenced a non-existent `hex_string` local — dead code
+      # that would NameError if ever reached.
+      #
       # Calculate the code point from the surrogate pair values
       # algorithm from https://russellcottrell.com/greek/utilities/SurrogatePairCalculator.htm
       high = high_surrogate_hex.hex
@@ -316,20 +344,19 @@ module Janeway
     #
     # @return [String]
     def consume_four_hex_digits
-      hex_digits = []
+      hex_digits = String.new(capacity: 4)
       4.times do
-        hex_digits << consume
-        case hex_digits.last.ord
-        when 0x30..0x39 then next # '0'..'1'
-        when 0x40..0x46 then next # 'A'..'F'
+        c = consume
+        hex_digits << c
+        case c.ord
+        when 0x30..0x39 then next # '0'..'9'
+        when 0x41..0x46 then next # 'A'..'F'
         when 0x61..0x66 then next # 'a'..'f'
         else
-          raise err("Invalid unicode escape sequence: \\u#{hex_digits.join}")
+          raise err("Invalid unicode escape sequence: \\u#{hex_digits}")
         end
       end
-      raise err("Incomplete unicode escape sequence: \\u#{hex_digits.join}") if hex_digits.size < 4
-
-      hex_digits.join
+      hex_digits
     end
 
     # Consume a numeric string. May be an integer, fractional, or exponent.
@@ -352,13 +379,13 @@ module Janeway
           consume # "+" / "-"
         end
         unless digit?(lookahead)
-          lexeme = source[lexeme_start_p..(next_p - 1)]
+          lexeme = current_lexeme
           raise err("Exponent 'e' must be followed by number: #{lexeme.inspect}")
         end
         consume_digits
       end
 
-      lexeme = source[lexeme_start_p..(next_p - 1)]
+      lexeme = current_lexeme
       if lexeme.start_with?('0') && lexeme.size > 1
         raise err("Number may not start with leading zero: #{lexeme.inspect}")
       end
@@ -374,36 +401,6 @@ module Janeway
 
     # Consume an alphanumeric string.
     # If `ignore_keywords`, the result is always an :identifier token.
-    # Otherwise, keywords and function names will be recognized and tokenized as those types.
-    #
-    # @param ignore_keywords [Boolean]
-    def lex_identifier(ignore_keywords: false)
-      consume while alpha_numeric?(lookahead)
-
-      identifier = source[lexeme_start_p..(next_p - 1)]
-      type =
-        if KEYWORD.include?(identifier) && !ignore_keywords
-          identifier.to_sym
-        elsif FUNCTIONS.include?(identifier) && !ignore_keywords
-          :function
-        else
-          :identifier
-        end
-
-      Token.new(type, identifier, identifier, current_location)
-    end
-
-    # Parse an identifier string which is not within delimiters.
-    # The standard set of unicode code points are allowed.
-    # No character escapes are allowed.
-    # Keywords and function names are ignored in this context.
-    # @return [Token]
-    def lex_unescaped_identifier
-      consume while unescaped?(lookahead)
-      identifier = source[lexeme_start_p..(next_p - 1)]
-      Token.new(:identifier, identifier, identifier, current_location)
-    end
-
     # Return true if string matches the definition of "unescaped" from RFC9535:
     # unescaped     = %x20-21 /        ; see RFC 8259
     #                    ; omit 0x22 "
@@ -427,19 +424,6 @@ module Janeway
       end
     end
 
-    def escapable?(char)
-      case char.ord
-      when 0x62 then true # backspace
-      when 0x66 then true # form feed
-      when 0x6E then true # line feed
-      when 0x72 then true # carriage return
-      when 0x74 then true # horizontal tab
-      when 0x2F then true # slash
-      when 0x5C then true # backslash
-      else false
-      end
-    end
-
     # True if character is suitable as the first character in a name selector
     # using shorthand notation (ie. no bracket notation.)
     #
@@ -470,6 +454,7 @@ module Janeway
     end
 
     # Lex a member name that is found within dot notation.
+    # This name is not delimited and allows a subset of the characters that can appear in a delimited string.
     #
     # Recognize keywords and given them the correct type.
     # @see https://www.rfc-editor.org/rfc/rfc9535.html#section-2.5.1.1-3
@@ -477,12 +462,16 @@ module Janeway
     # @param ignore_keywords [Boolean]
     # @return [Token]
     def lex_member_name_shorthand(ignore_keywords: false)
+      # Abort if name is preceded by child_start.  Catches non-delimited identifiers in brackets,
+      # eg.  $["key"] is allowed, but $[key] is not
+      raise err('Identifier within brackets must be surrounded by quotes') if previous_token_type == :child_start
+
       consume while name_char?(lookahead)
-      identifier = source[lexeme_start_p..(next_p - 1)]
+      identifier = current_lexeme
       type =
-        if KEYWORD.include?(identifier) && !ignore_keywords
+        if KEYWORD_SET.include?(identifier) && !ignore_keywords
           identifier.to_sym
-        elsif FUNCTIONS.include?(identifier) && !ignore_keywords
+        elsif FUNCTIONS_SET.include?(identifier) && !ignore_keywords
           :function
         else
           :identifier

data/lib/janeway/location.rb

@@ -1,3 +1,5 @@
 # frozen_string_literal: true
 
-Location = Struct.new(:col, :length)
+module Janeway
+  Location = Struct.new(:col, :length)
+end

data/lib/janeway/normalized_path.rb

@@ -11,6 +11,15 @@ module Janeway
     # Characters that do not need escaping, defined by hexadecimal range
     NORMAL_UNESCAPED_RANGES = [(0x20..0x26), (0x28..0x5B), (0x5D..0xD7FF), (0xE000..0x10FFFF)].freeze
 
+    # Fast-path check for `escape`: a single anchored regex covering the same
+    # ranges as NORMAL_UNESCAPED_RANGES. Avoids allocating a `chars` array and
+    # scanning four Range objects per character on the common all-normal case.
+    NORMAL_UNESCAPED_REGEX = Regexp.new(
+      '\A[' +
+      NORMAL_UNESCAPED_RANGES.map { |r| "\\u{#{r.min.to_s(16)}}-\\u{#{r.max.to_s(16)}}" }.join +
+      ']*\z'
+    ).freeze
+
     def self.normalize(value)
       case value
       when String then normalize_name(value)
@@ -33,8 +42,8 @@ module Janeway
     end
 
     def self.escape(str)
-      # Common case, all chars are normal.
-      return str if str.chars.all? { |char| NORMAL_UNESCAPED_RANGES.any? { |range| range.include?(char.ord) } }
+      # Common case, all chars are normal — one regex match, no allocations.
+      return str if NORMAL_UNESCAPED_REGEX.match?(str)
 
       # Some escaping must be done
       str.chars.map { |char| escape_char(char) }.join
@@ -46,11 +55,18 @@ module Janeway
     def self.escape_char(char)
       # Character ranges defined by https://www.rfc-editor.org/rfc/rfc9535.html#section-2.7-8
       case char.ord
-      when 0x20..0x26, 0x28..0x5B, 0x5D..0xD7FF, 0xE000..0x10FFFF # normal-unescaped range
-        char # unescaped
-      when 0x62, 0x66, 0x6E, 0x72, 0x74, 0x27, 0x5C # normal-escapable range
-        # backspace, form feed, line feed, carriage return, horizontal tab, apostrophe, backslash
-        "\\#{char}" # escaped
+      # normal-unescaped range
+      when 0x20..0x26, 0x28..0x5B, 0x5D..0xD7FF, 0xE000..0x10FFFF then char # unescaped
+
+      # normal-escapable range
+      when 0x08 then '\\b' # backspace
+      when 0x0C then '\\f' # form feed
+      when 0x0A then '\\n' # line feed / newline
+      when 0x0D then '\\r' # carriage return
+      when 0x09 then '\\t' # horizontal tab
+      when 0x27 then '\\\'' # apostrophe
+      when 0x5C then '\\\\' # backslash
+
       else # normal-hexchar range
         hex_encode_char(char)
       end