first

data/web/inc/lib/vendor/tightenco/collect/.github/workflows/run-tests.yml

@@ -0,0 +1,41 @@
+name: Run tests
+
+on:
+  push:
+    branches: [laravel-9-ongoing, laravel-8-ongoing]
+  pull_request:
+
+jobs:
+  tests:
+    strategy:
+      matrix:
+        os: [Ubuntu, macOS]
+        php: [7.3, 7.4, 8.0, 8.1]
+
+        include:
+          - os: Ubuntu
+            os-version: ubuntu-latest
+
+          - os: macOS
+            os-version: macos-latest
+
+    name: ${{ matrix.os }} - PHP ${{ matrix.php }}
+
+    runs-on: ${{ matrix.os-version }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          extensions: posix, dom, curl, libxml, mbstring, zip, pcntl, pdo, sqlite, pdo_sqlite, bcmath, soap, intl, gd, exif, iconv, imagick
+          coverage: none
+
+      - name: Install dependencies
+        run: composer update --prefer-stable --prefer-dist --no-interaction
+
+      - name: Run tests
+        run: bash upgrade.sh

data/web/inc/lib/vendor/tightenco/collect/branch-commit-push.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+
+
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+WHITE='\033[0;37m'
+RESET='\033[0m'
+
+function validateVersion()
+{
+    echo ""
+    passedVersion=$1
+    echo -e "${WHITE}-- Validating tag '$passedVersion'...${RESET}"
+
+    # Todo: validate the version here using a regex; if fail, just exit
+    #       ... expect 8.75.0, with no v in front of it
+
+    if [[ $passedVersion == '' ]]; then
+        echo -e "\n-- Invalid tag. Tags should be structured without v; e.g. 8.57.0"
+        exit
+    fi
+
+    echo -e "${WHITE}-- Tag valid.${RESET}"
+    echo ""
+}
+
+# Exit script if any command fails (e.g. phpunit)
+set -e
+
+
+# Require confirmation it's set up corrctly
+echo 
+echo -e "${WHITE}-- This script is meant to be run after running upgrade.sh, BEFORE committing to Git.${RESET}"
+
+while true; do
+    echo -e "${GREEN}-- Is that the current state of your local project?${RESET}"
+    read -p "-- (y/n) " yn
+    case $yn in
+        [Yy]* ) break;;
+        [Nn]* ) exit;;
+        * ) echo "Please answer y or n.";;
+    esac
+done
+
+# Get the version and exit if not valid
+validateVersion $1
+
+# Create official v prefaced version
+version="v$1"
+
+# Run tests (and bail if they fail)
+phpunit
+echo -e "\n${WHITE}-- Tests succeeded.${RESET}"
+
+# Branch
+echo -e "\n${WHITE}-- Creating a Git branch '$version-changes'...${RESET}\n"
+git checkout -b $version-changes
+
+# Add and commit, with "v8.57.0 changes" as the commit name
+git add -A
+git commit -m "$version changes"
+
+echo 
+echo -e "${WHITE}-- Git committed.${RESET}"
+
+# Push
+git push -u origin $version-changes

data/web/inc/lib/vendor/tightenco/collect/composer.json

@@ -0,0 +1,51 @@
+{
+    "name": "tightenco/collect",
+    "description": "Collect - Illuminate Collections as a separate package.",
+    "keywords": ["laravel", "collection"],
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylorotwell@gmail.com"
+        }
+    ],
+    "require": {
+        "php": "^7.3|^8.0",
+        "symfony/var-dumper": "^3.4 || ^4.0 || ^5.0 || ^6.0"
+    },
+    "require-dev": {
+        "mockery/mockery": "^1.0",
+        "phpunit/phpunit": "^8.3",
+        "nesbot/carbon": "^2.23.0"
+    },
+    "autoload": {
+        "files": [
+            "src/Collect/Support/helpers.php",
+            "src/Collect/Support/alias.php"
+        ],
+        "psr-4": {
+            "Tightenco\\Collect\\": "src/Collect"
+        }
+    },
+    "autoload-dev": {
+        "files": [
+            "tests/files/Support/Carbon.php",
+            "tests/files/Support/HtmlString.php",
+            "tests/files/Support/HigherOrderTapProxy.php",
+            "tests/files/Support/Str.php",
+            "tests/files/Support/Traits/Conditionable.php",
+            "tests/files/Support/Stringable.php",
+            "tests/files/Support/ItemNotFoundException.php",
+            "tests/files/Support/MultipleItemsFoundException.php",
+            "tests/Support/Concerns/CountsEnumerations.php"
+        ]
+    },
+    "scripts": {
+        "test": [
+            "@composer install",
+            "phpunit"
+        ]
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": true
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Contracts/Support/Arrayable.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Tightenco\Collect\Contracts\Support;
+
+interface Arrayable
+{
+    /**
+     * Get the instance as an array.
+     *
+     * @return array
+     */
+    public function toArray();
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Contracts/Support/CanBeEscapedWhenCastToString.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Tightenco\Collect\Contracts\Support;
+
+interface CanBeEscapedWhenCastToString
+{
+    /**
+     * Indicate that the object's string representation should be escaped when __toString is invoked.
+     *
+     * @param  bool  $escape
+     * @return $this
+     */
+    public function escapeWhenCastingToString($escape = true);
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Contracts/Support/Htmlable.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Tightenco\Collect\Contracts\Support;
+
+interface Htmlable
+{
+    /**
+     * Get content as a string of HTML.
+     *
+     * @return string
+     */
+    public function toHtml();
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Contracts/Support/Jsonable.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Tightenco\Collect\Contracts\Support;
+
+interface Jsonable
+{
+    /**
+     * Convert the object to its JSON representation.
+     *
+     * @param  int  $options
+     * @return string
+     */
+    public function toJson($options = 0);
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Support/Arr.php

@@ -0,0 +1,747 @@
+<?php
+
+namespace Tightenco\Collect\Support;
+
+use ArrayAccess;
+use Tightenco\Collect\Support\Traits\Macroable;
+use InvalidArgumentException;
+
+class Arr
+{
+    use Macroable;
+
+    /**
+     * Determine whether the given value is array accessible.
+     *
+     * @param  mixed  $value
+     * @return bool
+     */
+    public static function accessible($value)
+    {
+        return is_array($value) || $value instanceof ArrayAccess;
+    }
+
+    /**
+     * Add an element to an array using "dot" notation if it doesn't exist.
+     *
+     * @param  array  $array
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return array
+     */
+    public static function add($array, $key, $value)
+    {
+        if (is_null(static::get($array, $key))) {
+            static::set($array, $key, $value);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Collapse an array of arrays into a single array.
+     *
+     * @param  iterable  $array
+     * @return array
+     */
+    public static function collapse($array)
+    {
+        $results = [];
+
+        foreach ($array as $values) {
+            if ($values instanceof Collection) {
+                $values = $values->all();
+            } elseif (! is_array($values)) {
+                continue;
+            }
+
+            $results[] = $values;
+        }
+
+        return array_merge([], ...$results);
+    }
+
+    /**
+     * Cross join the given arrays, returning all possible permutations.
+     *
+     * @param  iterable  ...$arrays
+     * @return array
+     */
+    public static function crossJoin(...$arrays)
+    {
+        $results = [[]];
+
+        foreach ($arrays as $index => $array) {
+            $append = [];
+
+            foreach ($results as $product) {
+                foreach ($array as $item) {
+                    $product[$index] = $item;
+
+                    $append[] = $product;
+                }
+            }
+
+            $results = $append;
+        }
+
+        return $results;
+    }
+
+    /**
+     * Divide an array into two arrays. One with keys and the other with values.
+     *
+     * @param  array  $array
+     * @return array
+     */
+    public static function divide($array)
+    {
+        return [array_keys($array), array_values($array)];
+    }
+
+    /**
+     * Flatten a multi-dimensional associative array with dots.
+     *
+     * @param  iterable  $array
+     * @param  string  $prepend
+     * @return array
+     */
+    public static function dot($array, $prepend = '')
+    {
+        $results = [];
+
+        foreach ($array as $key => $value) {
+            if (is_array($value) && ! empty($value)) {
+                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
+            } else {
+                $results[$prepend.$key] = $value;
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Convert a flatten "dot" notation array into an expanded array.
+     *
+     * @param  iterable  $array
+     * @return array
+     */
+    public static function undot($array)
+    {
+        $results = [];
+
+        foreach ($array as $key => $value) {
+            static::set($results, $key, $value);
+        }
+
+        return $results;
+    }
+
+    /**
+     * Get all of the given array except for a specified array of keys.
+     *
+     * @param  array  $array
+     * @param  array|string  $keys
+     * @return array
+     */
+    public static function except($array, $keys)
+    {
+        static::forget($array, $keys);
+
+        return $array;
+    }
+
+    /**
+     * Determine if the given key exists in the provided array.
+     *
+     * @param  \ArrayAccess|array  $array
+     * @param  string|int  $key
+     * @return bool
+     */
+    public static function exists($array, $key)
+    {
+        if ($array instanceof Enumerable) {
+            return $array->has($key);
+        }
+
+        if ($array instanceof ArrayAccess) {
+            return $array->offsetExists($key);
+        }
+
+        return array_key_exists($key, $array);
+    }
+
+    /**
+     * Return the first element in an array passing a given truth test.
+     *
+     * @param  iterable  $array
+     * @param  callable|null  $callback
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public static function first($array, callable $callback = null, $default = null)
+    {
+        if (is_null($callback)) {
+            if (empty($array)) {
+                return value($default);
+            }
+
+            foreach ($array as $item) {
+                return $item;
+            }
+        }
+
+        foreach ($array as $key => $value) {
+            if ($callback($value, $key)) {
+                return $value;
+            }
+        }
+
+        return value($default);
+    }
+
+    /**
+     * Return the last element in an array passing a given truth test.
+     *
+     * @param  array  $array
+     * @param  callable|null  $callback
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public static function last($array, callable $callback = null, $default = null)
+    {
+        if (is_null($callback)) {
+            return empty($array) ? value($default) : end($array);
+        }
+
+        return static::first(array_reverse($array, true), $callback, $default);
+    }
+
+    /**
+     * Flatten a multi-dimensional array into a single level.
+     *
+     * @param  iterable  $array
+     * @param  int  $depth
+     * @return array
+     */
+    public static function flatten($array, $depth = INF)
+    {
+        $result = [];
+
+        foreach ($array as $item) {
+            $item = $item instanceof Collection ? $item->all() : $item;
+
+            if (! is_array($item)) {
+                $result[] = $item;
+            } else {
+                $values = $depth === 1
+                    ? array_values($item)
+                    : static::flatten($item, $depth - 1);
+
+                foreach ($values as $value) {
+                    $result[] = $value;
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Remove one or many array items from a given array using "dot" notation.
+     *
+     * @param  array  $array
+     * @param  array|string  $keys
+     * @return void
+     */
+    public static function forget(&$array, $keys)
+    {
+        $original = &$array;
+
+        $keys = (array) $keys;
+
+        if (count($keys) === 0) {
+            return;
+        }
+
+        foreach ($keys as $key) {
+            // if the exact key exists in the top-level, remove it
+            if (static::exists($array, $key)) {
+                unset($array[$key]);
+
+                continue;
+            }
+
+            $parts = explode('.', $key);
+
+            // clean up before each pass
+            $array = &$original;
+
+            while (count($parts) > 1) {
+                $part = array_shift($parts);
+
+                if (isset($array[$part]) && is_array($array[$part])) {
+                    $array = &$array[$part];
+                } else {
+                    continue 2;
+                }
+            }
+
+            unset($array[array_shift($parts)]);
+        }
+    }
+
+    /**
+     * Get an item from an array using "dot" notation.
+     *
+     * @param  \ArrayAccess|array  $array
+     * @param  string|int|null  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public static function get($array, $key, $default = null)
+    {
+        if (! static::accessible($array)) {
+            return value($default);
+        }
+
+        if (is_null($key)) {
+            return $array;
+        }
+
+        if (static::exists($array, $key)) {
+            return $array[$key];
+        }
+
+        if (strpos($key, '.') === false) {
+            return $array[$key] ?? value($default);
+        }
+
+        foreach (explode('.', $key) as $segment) {
+            if (static::accessible($array) && static::exists($array, $segment)) {
+                $array = $array[$segment];
+            } else {
+                return value($default);
+            }
+        }
+
+        return $array;
+    }
+
+    /**
+     * Check if an item or items exist in an array using "dot" notation.
+     *
+     * @param  \ArrayAccess|array  $array
+     * @param  string|array  $keys
+     * @return bool
+     */
+    public static function has($array, $keys)
+    {
+        $keys = (array) $keys;
+
+        if (! $array || $keys === []) {
+            return false;
+        }
+
+        foreach ($keys as $key) {
+            $subKeyArray = $array;
+
+            if (static::exists($array, $key)) {
+                continue;
+            }
+
+            foreach (explode('.', $key) as $segment) {
+                if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
+                    $subKeyArray = $subKeyArray[$segment];
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Determine if any of the keys exist in an array using "dot" notation.
+     *
+     * @param  \ArrayAccess|array  $array
+     * @param  string|array  $keys
+     * @return bool
+     */
+    public static function hasAny($array, $keys)
+    {
+        if (is_null($keys)) {
+            return false;
+        }
+
+        $keys = (array) $keys;
+
+        if (! $array) {
+            return false;
+        }
+
+        if ($keys === []) {
+            return false;
+        }
+
+        foreach ($keys as $key) {
+            if (static::has($array, $key)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Determines if an array is associative.
+     *
+     * An array is "associative" if it doesn't have sequential numerical keys beginning with zero.
+     *
+     * @param  array  $array
+     * @return bool
+     */
+    public static function isAssoc(array $array)
+    {
+        $keys = array_keys($array);
+
+        return array_keys($keys) !== $keys;
+    }
+
+    /**
+     * Determines if an array is a list.
+     *
+     * An array is a "list" if all array keys are sequential integers starting from 0 with no gaps in between.
+     *
+     * @param  array  $array
+     * @return bool
+     */
+    public static function isList($array)
+    {
+        return ! self::isAssoc($array);
+    }
+
+    /**
+     * Get a subset of the items from the given array.
+     *
+     * @param  array  $array
+     * @param  array|string  $keys
+     * @return array
+     */
+    public static function only($array, $keys)
+    {
+        return array_intersect_key($array, array_flip((array) $keys));
+    }
+
+    /**
+     * Pluck an array of values from an array.
+     *
+     * @param  iterable  $array
+     * @param  string|array|int|null  $value
+     * @param  string|array|null  $key
+     * @return array
+     */
+    public static function pluck($array, $value, $key = null)
+    {
+        $results = [];
+
+        [$value, $key] = static::explodePluckParameters($value, $key);
+
+        foreach ($array as $item) {
+            $itemValue = data_get($item, $value);
+
+            // If the key is "null", we will just append the value to the array and keep
+            // looping. Otherwise we will key the array using the value of the key we
+            // received from the developer. Then we'll return the final array form.
+            if (is_null($key)) {
+                $results[] = $itemValue;
+            } else {
+                $itemKey = data_get($item, $key);
+
+                if (is_object($itemKey) && method_exists($itemKey, '__toString')) {
+                    $itemKey = (string) $itemKey;
+                }
+
+                $results[$itemKey] = $itemValue;
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Explode the "value" and "key" arguments passed to "pluck".
+     *
+     * @param  string|array  $value
+     * @param  string|array|null  $key
+     * @return array
+     */
+    protected static function explodePluckParameters($value, $key)
+    {
+        $value = is_string($value) ? explode('.', $value) : $value;
+
+        $key = is_null($key) || is_array($key) ? $key : explode('.', $key);
+
+        return [$value, $key];
+    }
+
+    /**
+     * Push an item onto the beginning of an array.
+     *
+     * @param  array  $array
+     * @param  mixed  $value
+     * @param  mixed  $key
+     * @return array
+     */
+    public static function prepend($array, $value, $key = null)
+    {
+        if (func_num_args() == 2) {
+            array_unshift($array, $value);
+        } else {
+            $array = [$key => $value] + $array;
+        }
+
+        return $array;
+    }
+
+    /**
+     * Get a value from the array, and remove it.
+     *
+     * @param  array  $array
+     * @param  string  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public static function pull(&$array, $key, $default = null)
+    {
+        $value = static::get($array, $key, $default);
+
+        static::forget($array, $key);
+
+        return $value;
+    }
+
+    /**
+     * Convert the array into a query string.
+     *
+     * @param  array  $array
+     * @return string
+     */
+    public static function query($array)
+    {
+        return http_build_query($array, '', '&', PHP_QUERY_RFC3986);
+    }
+
+    /**
+     * Get one or a specified number of random values from an array.
+     *
+     * @param  array  $array
+     * @param  int|null  $number
+     * @param  bool|false  $preserveKeys
+     * @return mixed
+     *
+     * @throws \InvalidArgumentException
+     */
+    public static function random($array, $number = null, $preserveKeys = false)
+    {
+        $requested = is_null($number) ? 1 : $number;
+
+        $count = count($array);
+
+        if ($requested > $count) {
+            throw new InvalidArgumentException(
+                "You requested {$requested} items, but there are only {$count} items available."
+            );
+        }
+
+        if (is_null($number)) {
+            return $array[array_rand($array)];
+        }
+
+        if ((int) $number === 0) {
+            return [];
+        }
+
+        $keys = array_rand($array, $number);
+
+        $results = [];
+
+        if ($preserveKeys) {
+            foreach ((array) $keys as $key) {
+                $results[$key] = $array[$key];
+            }
+        } else {
+            foreach ((array) $keys as $key) {
+                $results[] = $array[$key];
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Set an array item to a given value using "dot" notation.
+     *
+     * If no key is given to the method, the entire array will be replaced.
+     *
+     * @param  array  $array
+     * @param  string|null  $key
+     * @param  mixed  $value
+     * @return array
+     */
+    public static function set(&$array, $key, $value)
+    {
+        if (is_null($key)) {
+            return $array = $value;
+        }
+
+        $keys = explode('.', $key);
+
+        foreach ($keys as $i => $key) {
+            if (count($keys) === 1) {
+                break;
+            }
+
+            unset($keys[$i]);
+
+            // If the key doesn't exist at this depth, we will just create an empty array
+            // to hold the next value, allowing us to create the arrays to hold final
+            // values at the correct depth. Then we'll keep digging into the array.
+            if (! isset($array[$key]) || ! is_array($array[$key])) {
+                $array[$key] = [];
+            }
+
+            $array = &$array[$key];
+        }
+
+        $array[array_shift($keys)] = $value;
+
+        return $array;
+    }
+
+    /**
+     * Shuffle the given array and return the result.
+     *
+     * @param  array  $array
+     * @param  int|null  $seed
+     * @return array
+     */
+    public static function shuffle($array, $seed = null)
+    {
+        if (is_null($seed)) {
+            shuffle($array);
+        } else {
+            mt_srand($seed);
+            shuffle($array);
+            mt_srand();
+        }
+
+        return $array;
+    }
+
+    /**
+     * Sort the array using the given callback or "dot" notation.
+     *
+     * @param  array  $array
+     * @param  callable|array|string|null  $callback
+     * @return array
+     */
+    public static function sort($array, $callback = null)
+    {
+        return Collection::make($array)->sortBy($callback)->all();
+    }
+
+    /**
+     * Recursively sort an array by keys and values.
+     *
+     * @param  array  $array
+     * @param  int  $options
+     * @param  bool  $descending
+     * @return array
+     */
+    public static function sortRecursive($array, $options = SORT_REGULAR, $descending = false)
+    {
+        foreach ($array as &$value) {
+            if (is_array($value)) {
+                $value = static::sortRecursive($value, $options, $descending);
+            }
+        }
+
+        if (static::isAssoc($array)) {
+            $descending
+                    ? krsort($array, $options)
+                    : ksort($array, $options);
+        } else {
+            $descending
+                    ? rsort($array, $options)
+                    : sort($array, $options);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Conditionally compile classes from an array into a CSS class list.
+     *
+     * @param  array  $array
+     * @return string
+     */
+    public static function toCssClasses($array)
+    {
+        $classList = static::wrap($array);
+
+        $classes = [];
+
+        foreach ($classList as $class => $constraint) {
+            if (is_numeric($class)) {
+                $classes[] = $constraint;
+            } elseif ($constraint) {
+                $classes[] = $class;
+            }
+        }
+
+        return implode(' ', $classes);
+    }
+
+    /**
+     * Filter the array using the given callback.
+     *
+     * @param  array  $array
+     * @param  callable  $callback
+     * @return array
+     */
+    public static function where($array, callable $callback)
+    {
+        return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
+    }
+
+    /**
+     * Filter items where the value is not null.
+     *
+     * @param  array  $array
+     * @return array
+     */
+    public static function whereNotNull($array)
+    {
+        return static::where($array, function ($value) {
+            return ! is_null($value);
+        });
+    }
+
+    /**
+     * If the given value is not an array and not null, wrap it in one.
+     *
+     * @param  mixed  $value
+     * @return array
+     */
+    public static function wrap($value)
+    {
+        if (is_null($value)) {
+            return [];
+        }
+
+        return is_array($value) ? $value : [$value];
+    }
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Support/HigherOrderCollectionProxy.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Tightenco\Collect\Support;
+
+/**
+ * @mixin \Tightenco\Collect\Support\Enumerable
+ */
+class HigherOrderCollectionProxy
+{
+    /**
+     * The collection being operated on.
+     *
+     * @var \Tightenco\Collect\Support\Enumerable
+     */
+    protected $collection;
+
+    /**
+     * The method being proxied.
+     *
+     * @var string
+     */
+    protected $method;
+
+    /**
+     * Create a new proxy instance.
+     *
+     * @param  \Tightenco\Collect\Support\Enumerable  $collection
+     * @param  string  $method
+     * @return void
+     */
+    public function __construct(Enumerable $collection, $method)
+    {
+        $this->method = $method;
+        $this->collection = $collection;
+    }
+
+    /**
+     * Proxy accessing an attribute onto the collection items.
+     *
+     * @param  string  $key
+     * @return mixed
+     */
+    public function __get($key)
+    {
+        return $this->collection->{$this->method}(function ($value) use ($key) {
+            return is_array($value) ? $value[$key] : $value->{$key};
+        });
+    }
+
+    /**
+     * Proxy a method call onto the collection items.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->collection->{$this->method}(function ($value) use ($method, $parameters) {
+            return $value->{$method}(...$parameters);
+        });
+    }
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Support/HigherOrderWhenProxy.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Tightenco\Collect\Support;
+
+/**
+ * @mixin \Tightenco\Collect\Support\Enumerable
+ */
+class HigherOrderWhenProxy
+{
+    /**
+     * The collection being operated on.
+     *
+     * @var \Tightenco\Collect\Support\Enumerable
+     */
+    protected $collection;
+
+    /**
+     * The condition for proxying.
+     *
+     * @var bool
+     */
+    protected $condition;
+
+    /**
+     * Create a new proxy instance.
+     *
+     * @param  \Tightenco\Collect\Support\Enumerable  $collection
+     * @param  bool  $condition
+     * @return void
+     */
+    public function __construct(Enumerable $collection, $condition)
+    {
+        $this->condition = $condition;
+        $this->collection = $collection;
+    }
+
+    /**
+     * Proxy accessing an attribute onto the collection.
+     *
+     * @param  string  $key
+     * @return mixed
+     */
+    public function __get($key)
+    {
+        return $this->condition
+            ? $this->collection->{$key}
+            : $this->collection;
+    }
+
+    /**
+     * Proxy a method call onto the collection.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->condition
+            ? $this->collection->{$method}(...$parameters)
+            : $this->collection;
+    }
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Support/Traits/Macroable.php

@@ -0,0 +1,126 @@
+<?php
+
+namespace Tightenco\Collect\Support\Traits;
+
+use BadMethodCallException;
+use Closure;
+use ReflectionClass;
+use ReflectionMethod;
+
+trait Macroable
+{
+    /**
+     * The registered string macros.
+     *
+     * @var array
+     */
+    protected static $macros = [];
+
+    /**
+     * Register a custom macro.
+     *
+     * @param  string  $name
+     * @param  object|callable  $macro
+     * @return void
+     */
+    public static function macro($name, $macro)
+    {
+        static::$macros[$name] = $macro;
+    }
+
+    /**
+     * Mix another object into the class.
+     *
+     * @param  object  $mixin
+     * @param  bool  $replace
+     * @return void
+     *
+     * @throws \ReflectionException
+     */
+    public static function mixin($mixin, $replace = true)
+    {
+        $methods = (new ReflectionClass($mixin))->getMethods(
+            ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED
+        );
+
+        foreach ($methods as $method) {
+            if ($replace || ! static::hasMacro($method->name)) {
+                $method->setAccessible(true);
+                static::macro($method->name, $method->invoke($mixin));
+            }
+        }
+    }
+
+    /**
+     * Checks if macro is registered.
+     *
+     * @param  string  $name
+     * @return bool
+     */
+    public static function hasMacro($name)
+    {
+        return isset(static::$macros[$name]);
+    }
+
+    /**
+     * Flush the existing macros.
+     *
+     * @return void
+     */
+    public static function flushMacros()
+    {
+        static::$macros = [];
+    }
+
+    /**
+     * Dynamically handle calls to the class.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     *
+     * @throws \BadMethodCallException
+     */
+    public static function __callStatic($method, $parameters)
+    {
+        if (! static::hasMacro($method)) {
+            throw new BadMethodCallException(sprintf(
+                'Method %s::%s does not exist.', static::class, $method
+            ));
+        }
+
+        $macro = static::$macros[$method];
+
+        if ($macro instanceof Closure) {
+            $macro = $macro->bindTo(null, static::class);
+        }
+
+        return $macro(...$parameters);
+    }
+
+    /**
+     * Dynamically handle calls to the class.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     *
+     * @throws \BadMethodCallException
+     */
+    public function __call($method, $parameters)
+    {
+        if (! static::hasMacro($method)) {
+            throw new BadMethodCallException(sprintf(
+                'Method %s::%s does not exist.', static::class, $method
+            ));
+        }
+
+        $macro = static::$macros[$method];
+
+        if ($macro instanceof Closure) {
+            $macro = $macro->bindTo($this, static::class);
+        }
+
+        return $macro(...$parameters);
+    }
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Support/Traits/Tappable.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Tightenco\Collect\Support\Traits;
+
+trait Tappable
+{
+    /**
+     * Call the given Closure with this instance then return the instance.
+     *
+     * @param  callable|null  $callback
+     * @return $this|\Tightenco\Collect\Support\HigherOrderTapProxy
+     */
+    public function tap($callback = null)
+    {
+        return tap($this, $callback);
+    }
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Support/alias.php

@@ -0,0 +1,24 @@
+<?php
+
+$aliases = [
+    Tightenco\Collect\Contracts\Support\Arrayable::class => Illuminate\Contracts\Support\Arrayable::class,
+    Tightenco\Collect\Contracts\Support\Jsonable::class => Illuminate\Contracts\Support\Jsonable::class,
+    Tightenco\Collect\Contracts\Support\Htmlable::class => Illuminate\Contracts\Support\Htmlable::class,
+    Tightenco\Collect\Contracts\Support\CanBeEscapedWhenCastToString::class => Illuminate\Contracts\Support\CanBeEscapedWhenCastToString::class,
+    Tightenco\Collect\Support\Arr::class => Illuminate\Support\Arr::class,
+    Tightenco\Collect\Support\Collection::class => Illuminate\Support\Collection::class,
+    Tightenco\Collect\Support\Enumerable::class => Illuminate\Support\Enumerable::class,
+    Tightenco\Collect\Support\HigherOrderCollectionProxy::class => Illuminate\Support\HigherOrderCollectionProxy::class,
+    Tightenco\Collect\Support\HigherOrderWhenProxy::class => Illuminate\Support\HigherOrderWhenProxy::class,
+    Tightenco\Collect\Support\LazyCollection::class => Illuminate\Support\LazyCollection::class,
+    Tightenco\Collect\Support\Traits\EnumeratesValues::class => Illuminate\Support\Traits\EnumeratesValues::class,
+];
+
+# echo "\n\n-- Aliasing....\n---------------------------------------------\n\n";
+
+foreach ($aliases as $tighten => $illuminate) {
+    if (! class_exists($illuminate) && ! interface_exists($illuminate) && ! trait_exists($illuminate)) {
+        # echo "Aliasing {$tighten} to {$illuminate}.\n";
+        class_alias($tighten, $illuminate);
+    }
+}

data/web/inc/lib/vendor/tightenco/collect/src/Collect/Support/helpers.php

@@ -0,0 +1,122 @@
+<?php
+
+use Tightenco\Collect\Support\Arr;
+use Tightenco\Collect\Support\Collection;
+use Tightenco\Collect\Support\HigherOrderTapProxy;
+use Symfony\Component\VarDumper\VarDumper;
+
+if (! class_exists(Illuminate\Support\Collection::class)) {
+    if (! function_exists('collect')) {
+        /**
+         * Create a collection from the given value.
+         *
+         * @param  mixed  $value
+         * @return \Tightenco\Collect\Support\Collection
+         */
+        function collect($value = null)
+        {
+            return new Collection($value);
+        }
+    }
+
+    if (! function_exists('value')) {
+        /**
+         * Return the default value of the given value.
+         *
+         * @param  mixed  $value
+         * @return mixed
+         */
+        function value($value, ...$args)
+        {
+            return $value instanceof Closure ? $value(...$args) : $value;
+        }
+    }
+
+    if (! function_exists('data_get')) {
+        /**
+         * Get an item from an array or object using "dot" notation.
+         *
+         * @param  mixed  $target
+         * @param  string|array|int|null  $key
+         * @param  mixed  $default
+         * @return mixed
+         */
+        function data_get($target, $key, $default = null)
+        {
+            if (is_null($key)) {
+                return $target;
+            }
+
+            $key = is_array($key) ? $key : explode('.', $key);
+
+            foreach ($key as $i => $segment) {
+                unset($key[$i]);
+
+                if (is_null($segment)) {
+                    return $target;
+                }
+
+                if ($segment === '*') {
+                    if ($target instanceof Collection) {
+                        $target = $target->all();
+                    } elseif (! is_array($target)) {
+                        return value($default);
+                    }
+
+                    $result = [];
+
+                    foreach ($target as $item) {
+                        $result[] = data_get($item, $key);
+                    }
+
+                    return in_array('*', $key) ? Arr::collapse($result) : $result;
+                }
+
+                if (Arr::accessible($target) && Arr::exists($target, $segment)) {
+                    $target = $target[$segment];
+                } elseif (is_object($target) && isset($target->{$segment})) {
+                    $target = $target->{$segment};
+                } else {
+                    return value($default);
+                }
+            }
+
+            return $target;
+        }
+    }
+
+    if (! function_exists('tap')) {
+        /**
+         * Call the given Closure with the given value then return the value.
+         *
+         * @param  mixed  $value
+         * @param  callable|null  $callback
+         * @return mixed
+         */
+        function tap($value, $callback = null)
+        {
+            if (is_null($callback)) {
+                return new HigherOrderTapProxy($value);
+            }
+
+            $callback($value);
+
+            return $value;
+        }
+    }
+
+    if (! function_exists('class_basename')) {
+        /**
+         * Get the class "basename" of the given object / class.
+         *
+         * @param  string|object  $class
+         * @return string
+         */
+        function class_basename($class)
+        {
+            $class = is_object($class) ? get_class($class) : $class;
+
+            return basename(str_replace('\\', '/', $class));
+        }
+    }
+}