@param array $default
@param mixed $apply

@return array
481907
protected function mergeConfiguration(array $default, $apply): array
    {
        foreach ($apply as $key => $item) {
            if (isset($default[$key]) && $this->isAssocArray($default[$key])) {
                $default[$key] = $this->mergeConfiguration($default[$key], $item);
            } else {
                $default[$key] = $item;
            }
        }

        return $default;
    }
132488
public function get($key, $default = null): array
    {
        if (!$this->has($key)) {
            if (\is_array($default)) {
                return $default;
            }

            return $default === null ? [] : [$default];
        }

        return $this->headers[Helpers::normalizeHeaderName($key)];
    }
105373
protected function fetchFromArray($index = null, $default = null)
    {
        $array = $this->collection->all();
        if (empty($array)) {
            return $default;
        }
        if (!is_array($array)) {
            throw new \ErrorException(
                'Invalid records for array collections',
                E_ERROR
            );
        }

        // If $index is NULL, it means that the whole $array is requested
        isset($index) || $index = array_keys($array);
        // allow fetching multiple keys at once
        if (is_array($index)) {
            $output = [];
            foreach ($index as $key) {
                $output[$key] = $this->fetchFromArray($key);
            }
            return $output;
        }
        if (isset($array[$index])) {
            $value = $array[$index];
        } elseif (($count = preg_match_all('/(?:^[^\[]+)|\[[^]]*\]/', $index, $matches)) > 1) {
            // Does the index contain array notation
            $value = $array;
            for ($i = 0; $i < $count; $i++) {
                $key = trim($matches[0][$i], '[]');
                // Empty notation will return the value as array
                if ($key === '') {
                    break;
                }
                if (isset($value[$key])) {
                    $value = $value[$key];
                } else {
                    return $default;
                }
            }
        } else {
            return $default;
        }

        return $value;
    }
538182
public function getParam($key, $default = null)
    {
        $params = $this->params;
        if (is_array($params) && isset($params[$key])) {
            $result = $params[$key];
        } else {
            if (!is_string($default) && is_callable($default)) {
                $result = $default();
            } else {
                $result = $default;
            }
        }

        return $result;
    }
114962
public function get($key, $default = NULL) {

		return array_key_exists($key, $this->data) ? $this->data[$key] : $default;

	}
741958
public static function get($array, $key, $default = null)
    {
        return is_array($key)
            ? static::getArray($array, $key, $default)
            : parent::get($array, $key, $default);
    }
1271233
public function getFromArray(string $key, array $data, string $default = null)
    {
        $value = $default;

        if (\array_key_exists($key, $data)) {
            $value = $data[$key];
        }

        return $value;
    }
35460
public static function get($array, $key, $default = null)
    {
        $key = static::normalizeKey($key);

        if ($key === null || $key === '')
        {
            return $array;
        }

        $keys = explode('.', $key);
        $currentElement = $array;

        foreach ($keys as $currentKey)
        {
            if (!is_array($currentElement) || !array_key_exists($currentKey, $currentElement))
            {
                return $default;
            }

            $currentElement = $currentElement[(string) $currentKey];
        }

        return $currentElement;
    }
67135
public function asArray(array $filters = [], $default = null) : array
    {
        $array = Validate::asArray($this->params[$this->key] ?? $this->params, []);

        foreach ($filters as $key => $dataType) {
            $dataType = 'as' . ucfirst($dataType);
            $array[$key] = Validate::$dataType($array[$key] ?? null, $default);
        }

        return $array;
    }
1309347
public function get(string $path, $default = null)
    {
        $array = $this->items;

        if (!empty($path)) {
            $keys = $this->explode($path);
            foreach ($keys as $key) {
                if (!array_key_exists($key, $array)) {
                    return $default;
                }
                $array = $array[$key];
            }
        }

        return $array;
    }
1077302
public function get($key = null, $default = null)
    {
        if (is_null($key)) {
            return $this->array;
        }

        if (false === strpos($key, $this->separator)) {
            return $this->array[$key] ?? $this->defaultValue($key, $default);
        }

        $keyArray = explode($this->separator, $key);
        $tmp      = $this->array;
        foreach ($keyArray as $k) {
            if (isset($tmp[$k])) {
                $tmp = $tmp[$k];
            } else {
                $tmp = $this->defaultValue($key, $default);
                break;
            }
        }
        return $tmp;
    }
232206
public function getAsArray($key, array $default = array())
    {
        $value = parent::get($key, $default);
        if (is_array($value) && !$value) $value = $default;
        return (array)$value;
    }
1326305
protected function arrayGet($key, $default = null)
    {
        if (isset($this->list[$key])) {
            return $this->list[$key];
        }

        foreach (explode('.', $key) as $segment) {
            if (! is_array($this->list) || ! array_key_exists($segment, $this->list)) {
                return (is_callable($default)) ? $default() : $default;
            }

            $this->list = $this->list[$segment];
        }

        return $this->list;
    }
388070
public static function Arr($array, $filter = null, $default = array())
  {
    if (empty($array) || !is_array($array)) {
      return $default;
    }

    $out = false;
    foreach ($array as $key => $val) {
      if (!is_null(static::Value($val, $filter, null))) {
        $out[$key] = $val;
      }
    }

    return $out ?: $default;
  }
9353
public function get($name, $default = null)
    {
        if (is_array($name)) {
            $result = [];

            foreach ($name as $key => $value) {
                if (is_int($key)) {
                    $result[$value] = $this->_get($value, $default);
                } else {
                    $result[$key] = $this->_get($key, $value);
                }
            }
            return $result;
        }
        return $this->_get($name, $default);
    }
547678
public function get($key, $default = null)
    {
        return array_key_exists($key, $this->collection) ? $this->collection[$key] : $default;
    }
1032407
public function get( $key = null, $default = null ) {
		return func_num_args() === 0 ? $_GET : $this->app->utility->array_get( $_GET, $key, $default );
	}