class Array

def self.wrap: (String? object) -> untyped

def self.wrap(object)
  if object.nil?
    []
  elsif object.respond_to?(:to_ary)
    object.to_ary || [object]
  else
    [object]
  end
end

def as_json: (?nil options) -> untyped

def as_json(options = nil) # :nodoc:
  map { |v| options ? v.as_json(options.dup) : v.as_json }
end

def compact_blank!
  # use delete_if rather than reject! because it always returns self even if nothing changed
  delete_if(&:blank?)
end

def deep_dup: () -> untyped

def deep_dup
  map(&:deep_dup)
end

def excluding(*elements)
  self - elements.flatten(1)
end

def extract!: () -> untyped

def extract!
  return to_enum(:extract!) { size } unless block_given?
  extracted_elements = []
  reject! do |element|
    extracted_elements << element if yield(element)
  end
  extracted_elements
end

def extract_options!: () -> untyped

def extract_options!
  if last.is_a?(Hash) && last.extractable_options?
    pop
  else
    {}
  end
end

def fifth
  self[4]
end

def forty_two
  self[41]
end

def fourth
  self[3]
end

def from(position)
  self[position, length] || []
end

def in_groups(number, fill_with = nil, &block)
  # size.div number gives minor group size;
  # size % number gives how many objects need extra accommodation;
  # each group hold either division or division + 1 items.
  division = size.div number
  modulo = size % number
  # create a new array avoiding dup
  groups = []
  start = 0
  number.times do |index|
    length = division + (modulo > 0 && modulo > index ? 1 : 0)
    groups << last_group = slice(start, length)
    last_group << fill_with if fill_with != false &&
      modulo > 0 && length == division
    start += length
  end
  if block_given?
    groups.each(&block)
  else
    groups
  end
end

def in_groups_of(number, fill_with = nil, &block)
  if number.to_i <= 0
    raise ArgumentError,
      "Group size must be a positive integer, was #{number.inspect}"
  end
  if fill_with == false
    collection = self
  else
    # size % number gives how many extra we have;
    # subtracting from number gives how many to add;
    # modulo number ensures we don't add group of just fill.
    padding = (number - size % number) % number
    collection = dup.concat(Array.new(padding, fill_with))
  end
  if block_given?
    collection.each_slice(number, &block)
  else
    collection.each_slice(number).to_a
  end
end

def including(*elements)
  self + elements.flatten(1)
end

def inquiry
  ActiveSupport::ArrayInquirer.new(self)
end

def second
  self[1]
end

def second_to_last
  self[-2]
end

def split(value = nil, &block)
  arr = dup
  result = []
  if block_given?
    while (idx = arr.index(&block))
      result << arr.shift(idx)
      arr.shift
    end
  else
    while (idx = arr.index(value))
      result << arr.shift(idx)
      arr.shift
    end
  end
  result << arr
end

def sum(init = nil, &block)
  if init.is_a?(Numeric) || first.is_a?(Numeric)
    init ||= 0
    orig_sum(init, &block)
  else
    super
  end
end

def third
  self[2]
end

def third_to_last
  self[-3]
end

def to(position)
  if position >= 0
    take position + 1
  else
    self[0..position]
  end
end

def to_fs(format = :default)
  case format
  when :db
    if empty?
      "null"
    else
      collect(&:id).join(",")
    end
  else
    to_default_s
  end
end

def to_param
  collect(&:to_param).join "/"
end

def to_query(key)
  prefix = "#{key}[]"
  if empty?
    nil.to_query(prefix)
  else
    collect { |value| value.to_query(prefix) }.join "&"
  end
end

def to_s(format = NOT_SET) # :nodoc:
  case format
  when :db
    ActiveSupport::Deprecation.warn(
      "Array#to_s(#{format.inspect}) is deprecated. Please use Array#to_fs(#{format.inspect}) instead."
    )
    if empty?
      "null"
    else
      collect(&:id).join(",")
    end
  when NOT_SET
    to_default_s
  else
    ActiveSupport::Deprecation.warn(
      "Array#to_s(#{format.inspect}) is deprecated. Please use Array#to_fs(#{format.inspect}) instead."
    )
    to_default_s
  end
end

def to_sentence(options = {})
  options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
  default_connectors = {
    words_connector: ", ",
    two_words_connector: " and ",
    last_word_connector: ", and "
  }
  if options[:locale] != false && defined?(I18n)
    i18n_connectors = I18n.translate(:'support.array', locale: options[:locale], default: {})
    default_connectors.merge!(i18n_connectors)
  end
  options = default_connectors.merge!(options)
  case length
  when 0
    +""
  when 1
    +"#{self[0]}"
  when 2
    +"#{self[0]}#{options[:two_words_connector]}#{self[1]}"
  else
    +"#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
  end
end