diff --git a/civicrm/vendor/civicrm/composer-compile-lib/.gitignore b/civicrm/vendor/civicrm/composer-compile-lib/.gitignore
index e79fe3232e889c72574a2e6ea04b0f607fe7cc23..de3d6542cca4e0ecbf13e4c0650bf32423e63bb4 100644
--- a/civicrm/vendor/civicrm/composer-compile-lib/.gitignore
+++ b/civicrm/vendor/civicrm/composer-compile-lib/.gitignore
@@ -1,7 +1,6 @@
-/CCL.php
/tests/examples/scss/dist
/tests/examples/scss/output.css
/tests/examples/scss/output.min.css
/vendor/
/.idea/
-*~
\ No newline at end of file
+*~
diff --git a/civicrm/vendor/civicrm/composer-compile-lib/CCL.php b/civicrm/vendor/civicrm/composer-compile-lib/CCL.php
new file mode 100644
index 0000000000000000000000000000000000000000..68fc4f704fc664ac0ae2dc0b2a624c51f98d838d
--- /dev/null
+++ b/civicrm/vendor/civicrm/composer-compile-lib/CCL.php
@@ -0,0 +1,362 @@
+<?php
+// AUTO-GENERATED VIA /home/publisher/bknix-min/build/cividist/src/vendor/civicrm/composer-compile-lib/src/StubsTpl.php
+// If this file somehow becomes invalid (eg when patching CCL), you may safely delete and re-run install.
+use Symfony\Component\Filesystem\Exception\IOException;
+use Symfony\Component\Filesystem\Exception\FileNotFoundException;
+
+class CCL {
+
+ /**
+ * @return Symfony\Component\Filesystem\Filesystem
+ */
+ public static function _sym() {
+ static $singleton = NULL;
+ $singleton = $singleton ?: new \Symfony\Component\Filesystem\Filesystem();
+ return $singleton;
+ }
+
+ /**
+ * @return CCL\Functions
+ */
+ public static function _ccl() {
+ static $singleton = NULL;
+ $singleton = $singleton ?: new \CCL\Functions();
+ return $singleton;
+ }
+
+ /**
+ * Copies a file.
+ *
+ * If the target file is older than the origin file, it's always overwritten.
+ * If the target file is newer, it is overwritten only when the
+ * $overwriteNewerFiles option is set to true.
+ *
+ * @param string $originFile The original filename
+ * @param string $targetFile The target filename
+ * @param bool $overwriteNewerFiles If true, target files newer than origin files are overwritten
+ *
+ * @throws FileNotFoundException When originFile doesn't exist
+ * @throws IOException When copy fails
+ */
+ public static function copy($originFile, $targetFile, bool $overwriteNewerFiles = TRUE) {
+ self::_sym()->copy($originFile, $targetFile, $overwriteNewerFiles);
+ }
+
+ /**
+ * Creates a directory recursively.
+ *
+ * @param string|iterable $dirs The directory path
+ * @param int $mode The directory mode
+ *
+ * @throws IOException On any directory creation failure
+ */
+ public static function mkdir($dirs, $mode = 511) {
+ self::_sym()->mkdir($dirs, $mode);
+ }
+
+ /**
+ * Checks the existence of files or directories.
+ *
+ * @param string|iterable $files A filename, an array of files, or a \Traversable instance to check
+ *
+ * @return bool true if the file exists, false otherwise
+ */
+ public static function exists($files) {
+ return self::_sym()->exists($files);
+ }
+
+ /**
+ * Sets access and modification time of file.
+ *
+ * @param string|iterable $files A filename, an array of files, or a \Traversable instance to create
+ * @param int|null $time The touch time as a Unix timestamp, if not supplied the current system time is used
+ * @param int|null $atime The access time as a Unix timestamp, if not supplied the current system time is used
+ *
+ * @throws IOException When touch fails
+ */
+ public static function touch($files, $time = NULL, $atime = NULL) {
+ self::_sym()->touch($files, $time, $atime);
+ }
+
+ /**
+ * Removes files or directories.
+ *
+ * @param string|iterable $files A filename, an array of files, or a \Traversable instance to remove
+ *
+ * @throws IOException When removal fails
+ */
+ public static function remove($files) {
+ self::_sym()->remove($files);
+ }
+
+ /**
+ * Change mode for an array of files or directories.
+ *
+ * @param string|iterable $files A filename, an array of files, or a \Traversable instance to change mode
+ * @param int $mode The new mode (octal)
+ * @param int $umask The mode mask (octal)
+ * @param bool $recursive Whether change the mod recursively or not
+ *
+ * @throws IOException When the change fails
+ */
+ public static function chmod($files, $mode, $umask = 0, $recursive = FALSE) {
+ self::_sym()->chmod($files, $mode, $umask, $recursive);
+ }
+
+ /**
+ * Change the owner of an array of files or directories.
+ *
+ * @param string|iterable $files A filename, an array of files, or a \Traversable instance to change owner
+ * @param string|int $user A user name or number
+ * @param bool $recursive Whether change the owner recursively or not
+ *
+ * @throws IOException When the change fails
+ */
+ public static function chown($files, $user, $recursive = FALSE) {
+ self::_sym()->chown($files, $user, $recursive);
+ }
+
+ /**
+ * Change the group of an array of files or directories.
+ *
+ * @param string|iterable $files A filename, an array of files, or a \Traversable instance to change group
+ * @param string|int $group A group name or number
+ * @param bool $recursive Whether change the group recursively or not
+ *
+ * @throws IOException When the change fails
+ */
+ public static function chgrp($files, $group, $recursive = FALSE) {
+ self::_sym()->chgrp($files, $group, $recursive);
+ }
+
+ /**
+ * Renames a file or a directory.
+ *
+ * @param string $origin The origin filename or directory
+ * @param string $target The new filename or directory
+ * @param bool $overwrite Whether to overwrite the target if it already exists
+ *
+ * @throws IOException When target file or directory already exists
+ * @throws IOException When origin cannot be renamed
+ */
+ public static function rename($origin, $target, $overwrite = FALSE) {
+ self::_sym()->rename($origin, $target, $overwrite);
+ }
+
+ /**
+ * Creates a symbolic link or copy a directory.
+ *
+ * @param string $originDir The origin directory path
+ * @param string $targetDir The symbolic link name
+ * @param bool $copyOnWindows Whether to copy files if on Windows
+ *
+ * @throws IOException When symlink fails
+ */
+ public static function symlink($originDir, $targetDir, $copyOnWindows = FALSE) {
+ self::_sym()->symlink($originDir, $targetDir, $copyOnWindows);
+ }
+
+ /**
+ * Creates a hard link, or several hard links to a file.
+ *
+ * @param string $originFile The original file
+ * @param string|string[] $targetFiles The target file(s)
+ *
+ * @throws FileNotFoundException When original file is missing or not a file
+ * @throws IOException When link fails, including if link already exists
+ */
+ public static function hardlink($originFile, $targetFiles) {
+ self::_sym()->hardlink($originFile, $targetFiles);
+ }
+
+ /**
+ * Resolves links in paths.
+ *
+ * With $canonicalize = false (default)
+ * - if $path does not exist or is not a link, returns null
+ * - if $path is a link, returns the next direct target of the link without considering the existence of the target
+ *
+ * With $canonicalize = true
+ * - if $path does not exist, returns null
+ * - if $path exists, returns its absolute fully resolved final version
+ *
+ * @param string $path A filesystem path
+ * @param bool $canonicalize Whether or not to return a canonicalized path
+ *
+ * @return string|null
+ */
+ public static function readlink($path, $canonicalize = FALSE) {
+ return self::_sym()->readlink($path, $canonicalize);
+ }
+
+ /**
+ * Given an existing path, convert it to a path relative to a given starting path.
+ *
+ * @param string $endPath Absolute path of target
+ * @param string $startPath Absolute path where traversal begins
+ *
+ * @return string Path of target relative to starting path
+ */
+ public static function makePathRelative($endPath, $startPath) {
+ return self::_sym()->makePathRelative($endPath, $startPath);
+ }
+
+ /**
+ * Mirrors a directory to another.
+ *
+ * Copies files and directories from the origin directory into the target directory. By default:
+ *
+ * - existing files in the target directory will be overwritten, except if they are newer (see the `override` option)
+ * - files in the target directory that do not exist in the source directory will not be deleted (see the `delete` option)
+ *
+ * @param string $originDir The origin directory
+ * @param string $targetDir The target directory
+ * @param \Traversable|null $iterator Iterator that filters which files and directories to copy, if null a recursive iterator is created
+ * @param array $options An array of boolean options
+ * Valid options are:
+ * - $options['override'] If true, target files newer than origin files are overwritten (see copy(), defaults to false)
+ * - $options['copy_on_windows'] Whether to copy files instead of links on Windows (see symlink(), defaults to false)
+ * - $options['delete'] Whether to delete files that are not in the source directory (defaults to false)
+ *
+ * @throws IOException When file type is unknown
+ */
+ public static function mirror($originDir, $targetDir, $iterator = NULL, $options = []) {
+ self::_sym()->mirror($originDir, $targetDir, $iterator, $options);
+ }
+
+ /**
+ * Returns whether the file path is an absolute path.
+ *
+ * @param string $file A file path
+ *
+ * @return bool
+ */
+ public static function isAbsolutePath($file) {
+ return self::_sym()->isAbsolutePath($file);
+ }
+
+ /**
+ * Creates a temporary file with support for custom stream wrappers.
+ *
+ * @param string $dir The directory where the temporary filename will be created
+ * @param string $prefix The prefix of the generated temporary filename
+ * Note: Windows uses only the first three characters of prefix
+ *
+ * @return string The new temporary filename (with path), or throw an exception on failure
+ */
+ public static function tempnam($dir, $prefix) {
+ return self::_sym()->tempnam($dir, $prefix);
+ }
+
+ /**
+ * Atomically dumps content into a file.
+ *
+ * @param string $filename The file to be written to
+ * @param string $content The data to write into the file
+ *
+ * @throws IOException if the file cannot be written to
+ */
+ public static function dumpFile($filename, $content) {
+ self::_sym()->dumpFile($filename, $content);
+ }
+
+ /**
+ * Appends content to an existing file.
+ *
+ * @param string $filename The file to which to append content
+ * @param string $content The content to append
+ *
+ * @throws IOException If the file is not writable
+ */
+ public static function appendToFile($filename, $content) {
+ self::_sym()->appendToFile($filename, $content);
+ }
+
+ /**
+ * Assert that we are properly executing within the context of a compilation task.
+ *
+ * If this script tries to run in any other context, then you will get some
+ * kind of error (e.g. class not found or RuntimeException).
+ */
+ public static function assertTask() {
+ self::_ccl()->assertTask();
+ }
+
+ /**
+ * Array-map function. Similar to array_map(), but tuned to key-value pairs.
+ *
+ * Example:
+ * $data = [100 => 'apple', 200 => 'banana'];
+ * $opposite = mapkv($data, function($k, $v){ return [-1 * $k => strtoupper($v)]; });
+ *
+ * This would return [-100 => 'APPLE', -200 => 'BANANA']
+ *
+ * By convention, mapping functions should return an 1-row array "[newKey => newValue]".
+ *
+ * Some unconventional forms are also defined:
+ * - Return empty array ==> Skip/omit the row
+ * - Return multiple items ==> Add all items to the result
+ * - Return an unkeyed (numeric) array ==> Discard original keys. Items are appended numerically (`$arr[] = $value`).
+ *
+ * @param array $array
+ * Values to iterate over
+ * @param callable $func
+ * Callback function.
+ * function(scalar $key, mixed $value): array
+ * @return array
+ * The filtered array.
+ */
+ public static function mapkv($array, $func) {
+ return self::_ccl()->mapkv($array, $func);
+ }
+
+ /**
+ * Map file-names.
+ *
+ * @param string $matchPat
+ * Ex: 'src/*.json'
+ * @param string $outPat
+ * Ex: 'dest/#1.json'
+ * @param bool $flip
+ * The orientation of the result map.
+ * If false, returned as "original => filtered".
+ * If true, returned as "filtered => original".
+ * @return array
+ * List of files and the corresponding names.
+ */
+ public static function globMap($matchPat, $outPat, $flip = FALSE) {
+ return self::_ccl()->globMap($matchPat, $outPat, $flip);
+ }
+
+
+ public static function chdir($directory) {
+ self::_ccl()->chdir($directory);
+ }
+
+ /**
+ * @param string|string[] $pats
+ * List of glob patterns.
+ * @param null|int $flags
+ * @return array
+ * List of matching files.
+ */
+ public static function glob($pats, $flags = NULL) {
+ return self::_ccl()->glob($pats, $flags);
+ }
+
+ /**
+ * Read a set of files and concatenate the results
+ *
+ * @param string|string[] $srcs
+ * Files to read. These may be globs.
+ * @param string $newLine
+ * Whether to ensure that joined files have a newline separator.
+ * Ex: 'raw' (as-is), 'auto' (add if missing)
+ * @return string
+ * The result of joining the files.
+ */
+ public static function cat($srcs, $newLine = 'auto') {
+ return self::_ccl()->cat($srcs, $newLine);
+ }
+
+}
diff --git a/civicrm/vendor/padaliyajay/php-autoprefixer/.gitignore b/civicrm/vendor/padaliyajay/php-autoprefixer/.gitignore
index 660d4197226ef223c46fef2842c4f0b89295c019..315293635071ce3ebf4609da56228d057e18a7ce 100644
--- a/civicrm/vendor/padaliyajay/php-autoprefixer/.gitignore
+++ b/civicrm/vendor/padaliyajay/php-autoprefixer/.gitignore
@@ -1,3 +1,2 @@
-/nbproject/
/test/nbproject/private/
-/test/
\ No newline at end of file
+/test/
diff --git a/civicrm/vendor/padaliyajay/php-autoprefixer/nbproject/project.properties b/civicrm/vendor/padaliyajay/php-autoprefixer/nbproject/project.properties
new file mode 100644
index 0000000000000000000000000000000000000000..76f6f918396fa724692f20def125cd2d84c4755d
--- /dev/null
+++ b/civicrm/vendor/padaliyajay/php-autoprefixer/nbproject/project.properties
@@ -0,0 +1,7 @@
+include.path=${php.global.include.path}
+php.version=PHP_56
+source.encoding=UTF-8
+src.dir=.
+tags.asp=false
+tags.short=false
+web.root=.
diff --git a/civicrm/vendor/padaliyajay/php-autoprefixer/nbproject/project.xml b/civicrm/vendor/padaliyajay/php-autoprefixer/nbproject/project.xml
new file mode 100644
index 0000000000000000000000000000000000000000..cad6b3d9bd5154fe51c78c5904b876c92d87e2c6
--- /dev/null
+++ b/civicrm/vendor/padaliyajay/php-autoprefixer/nbproject/project.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://www.netbeans.org/ns/project/1">
+ <type>org.netbeans.modules.php.project</type>
+ <configuration>
+ <data xmlns="http://www.netbeans.org/ns/php-project/1">
+ <name>php-autoprefixer</name>
+ </data>
+ </configuration>
+</project>