class Prism::CodeUnitsCache


has not yet been implemented.
introduce some kind of LRU cache to limit the number of entries, but this
* The second is that this cache is currently unbounded. In theory we could
being off by one or more code units.
not on character boundaries. This can result in subsequent computations
* The first is that there are issues when the cache computes values that are
in the future:
Note that there are some known issues here that may or may not be addressed
cache in order to minimize surface area.
offsets. It purposefully provides only a single #[] method to access the
A cache that can be used to quickly compute code unit offsets from byte

def [](byte_offset)

Retrieve the code units offset from the given byte offset. 
def [](byte_offset)
  @cache[byte_offset] ||=
    if (index = @offsets.bsearch_index { |offset| offset > byte_offset }).nil?
      @offsets << byte_offset
      @counter.count(0, byte_offset)
    elsif index == 0
      @offsets.unshift(byte_offset)
      @counter.count(0, byte_offset)
    else
      @offsets.insert(index, byte_offset)
      offset = @offsets[index - 1]
      @cache[offset] + @counter.count(offset, byte_offset - offset)
    end
end

def initialize(source, encoding)

Initialize a new cache with the given source and encoding. 
def initialize(source, encoding)
  @source = source
  @counter =
    if encoding == Encoding::UTF_16LE || encoding == Encoding::UTF_16BE
      UTF16Counter.new(source, encoding)
    else
      LengthCounter.new(source, encoding)
    end
  @cache = {} #: Hash[Integer, Integer]
  @offsets = [] #: Array[Integer]
end