<?php

use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Filesystem\Exception\IOException;

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.
	 *
	 * @throws FileNotFoundException When originFile doesn't exist
	 * @throws IOException           When copy fails
	 *
	 * @return void
	 */
	public static function copy($originFile, $targetFile, bool $overwriteNewerFiles = TRUE)
	{
		return self::_sym()->copy($originFile, $targetFile, $overwriteNewerFiles);
	}


	/**
	 * Creates a directory recursively.
	 *
	 * @throws IOException On any directory creation failure
	 *
	 * @return void
	 */
	public static function mkdir($dirs, $mode = 511)
	{
		return self::_sym()->mkdir($dirs, $mode);
	}


	/**
	 * Checks the existence of files or directories.
	 */
	public static function exists($files)
	{
		self::_sym()->exists($files);
	}


	/**
	 * Sets access and modification time of file.
	 *
	 * @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
	 *
	 * @return void
	 */
	public static function touch($files, $time = NULL, $atime = NULL)
	{
		return self::_sym()->touch($files, $time, $atime);
	}


	/**
	 * Removes files or directories.
	 *
	 * @throws IOException When removal fails
	 *
	 * @return void
	 */
	public static function remove($files)
	{
		return self::_sym()->remove($files);
	}


	/**
	 * Change mode for an array of files or directories.
	 *
	 * @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
	 *
	 * @return void
	 */
	public static function chmod($files, $mode, $umask = 0, $recursive = FALSE)
	{
		return self::_sym()->chmod($files, $mode, $umask, $recursive);
	}


	/**
	 * Change the owner of an array of files or directories.
	 *
	 * @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
	 *
	 * @return void
	 */
	public static function chown($files, $user, $recursive = FALSE)
	{
		return self::_sym()->chown($files, $user, $recursive);
	}


	/**
	 * Change the group of an array of files or directories.
	 *
	 * @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
	 *
	 * @return void
	 */
	public static function chgrp($files, $group, $recursive = FALSE)
	{
		return self::_sym()->chgrp($files, $group, $recursive);
	}


	/**
	 * Renames a file or a directory.
	 *
	 * @throws IOException When target file or directory already exists
	 * @throws IOException When origin cannot be renamed
	 *
	 * @return void
	 */
	public static function rename($origin, $target, $overwrite = FALSE)
	{
		return self::_sym()->rename($origin, $target, $overwrite);
	}


	/**
	 * Creates a symbolic link or copy a directory.
	 *
	 * @throws IOException When symlink fails
	 *
	 * @return void
	 */
	public static function symlink($originDir, $targetDir, $copyOnWindows = FALSE)
	{
		return self::_sym()->symlink($originDir, $targetDir, $copyOnWindows);
	}


	/**
	 * Creates a hard link, or several hard links to a 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
	 *
	 * @return void
	 */
	public static function hardlink($originFile, $targetFiles)
	{
		return 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
	 */
	public static function readlink($path, $canonicalize = FALSE)
	{
		self::_sym()->readlink($path, $canonicalize);
	}


	/**
	 * Given an existing path, convert it to a path relative to a given starting path.
	 */
	public static function makePathRelative($endPath, $startPath)
	{
		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 \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
	 *
	 * @return void
	 */
	public static function mirror($originDir, $targetDir, $iterator = NULL, $options = [])
	{
		return self::_sym()->mirror($originDir, $targetDir, $iterator, $options);
	}


	/**
	 * Returns whether the file path is an absolute path.
	 */
	public static function isAbsolutePath($file)
	{
		self::_sym()->isAbsolutePath($file);
	}


	/**
	 * Creates a temporary file with support for custom stream wrappers.
	 *
	 * @param string $prefix The prefix of the generated temporary filename
	 *                       Note: Windows uses only the first three characters of prefix
	 * @param string $suffix The suffix of the generated temporary filename
	 *
	 * @return string The new temporary filename (with path), or throw an exception on failure
	 */
	public static function tempnam($dir, $prefix, $suffix = '')
	{
		return self::_sym()->tempnam($dir, $prefix, $suffix);
	}


	/**
	 * Atomically dumps content into a file.
	 *
	 * @param string|resource $content The data to write into the file
	 *
	 * @throws IOException if the file cannot be written to
	 *
	 * @return void
	 */
	public static function dumpFile($filename, $content)
	{
		return self::_sym()->dumpFile($filename, $content);
	}


	/**
	 * Appends content to an existing file.
	 *
	 * @param string|resource $content The content to append
	 * @param bool            $lock    Whether the file should be locked when writing to it
	 *
	 * @throws IOException If the file is not writable
	 *
	 * @return void
	 */
	public static function appendToFile($filename, $content)
	{
		return 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);
	}
}
__halt_compiler();----SIGNATURE:----yRKkDBrnLETykwzYZRHjKj2PobgtwQhEzi9RNAxQJTV9Pyw366d+Zs5b6rmM1xyyKWaobOownre6sYmr7T2yZtO7YjCMjxybWGgrk+DumvlQZ8+yMD8O8LUsWZMRwY8c6napFNAz58hSOgQiBJMRFwTr1WMpY+AwVHiU0xTDtWygowGnTO5hjWGS+EcohREQiYtctCTwcoXLqjjjJXWbmTuwExHZ/ub9raQq23KZuFSovCv5TCSqRrBdgefp7HPiQMinsNeQXMVlMiy2gAkz9CqD6VkoqGVJWSJmGYaUpb0u5P47mgcusCg2Z2/COdpOo3eeNct+nGZh3IRRN/rnmrwVQJTANDKxA/lQSWAILbYdxlk+MFG/SEPcBH8Q3EXFeZL05IBRJLqQFZDYP5kNBS0mauShcCic7eS19l3JpZ4DPuvXLDgyjtwxhfZxZ+7lt5plViaw7TGa8N7D96d1mNwo9TzYKMU35L5zuMI3va+maAYFYodG5q31bhWI8ISxmR8O+ohhDerbAZbkasdTquIHVDDrDHTY/A4tEalDiY0pKif5Cx8uceQZC4sG/mGUxoBVTGFYorTdfOpRnxykq5M3hjKfod7exPzL9odOhah77MhJZ6fuQcqU11GXyb8M4jaV5ghHcGNYjI5N9MpoPnc5tgGvtlYCgZUiOSfbucQ=----ATTACHMENT:----MzEzNzQwNTk3Mzk0ODUyNiAyMzc2OTcxMzE4NjgxMTE1IDgzMzQ3OTE0OTEzNzE4Mzc=