Reworking the build system

1 files changed, 0 insertions, 658 deletions

diff --git a/source/kit/miniz/miniz.h b/source/kit/miniz/miniz.h
deleted file mode 100644
index a80c389..0000000
--- a/source/kit/miniz/miniz.h
+++ /dev/null
@@ -1,658 +0,0 @@
-/* miniz.c 3.0.2 - public domain deflate/inflate, zlib-subset, ZIP
-   reading/writing/appending, PNG writing See "unlicense" statement at
-   the end of this file. Rich Geldreich <richgel99@gmail.com>, last
-   updated Oct. 13, 2013 Implements RFC 1950:
-   http://www.ietf.org/rfc/rfc1950.txt and RFC 1951:
-   http://www.ietf.org/rfc/rfc1951.txt
-
-   Most API's defined in miniz.c are optional. For example, to disable
-   the archive related functions just define MINIZ_NO_ARCHIVE_APIS, or
-   to get rid of all stdio usage define MINIZ_NO_STDIO (see the list
-   below for more macros).
-
-   * Low-level Deflate/Inflate implementation notes:
-
-     Compression: Use the "tdefl" API's. The compressor supports raw,
-   static, and dynamic blocks, lazy or greedy parsing, match length
-   filtering, RLE-only, and Huffman-only streams. It performs and
-   compresses approximately as well as zlib.
-
-     Decompression: Use the "tinfl" API's. The entire decompressor is
-   implemented as a single function coroutine: see tinfl_decompress().
-   It supports decompression into a 32KB (or larger power of 2)
-   wrapping buffer, or into a memory block large enough to hold the
-   entire file.
-
-     The low-level tdefl/tinfl API's do not make any use of dynamic
-   memory allocation.
-
-   * zlib-style API notes:
-
-     miniz.c implements a fairly large subset of zlib. There's enough
-   functionality present for it to be a drop-in zlib replacement in
-   many apps: The z_stream struct, optional memory allocation
-   callbacks
-        deflateInit/deflateInit2/deflate/deflateReset/deflateEnd/deflateBound
-        inflateInit/inflateInit2/inflate/inflateReset/inflateEnd
-        compress, compress2, compressBound, uncompress
-        CRC-32, Adler-32 - Using modern, minimal code size, CPU cache
-   friendly routines. Supports raw deflate streams or standard zlib
-   streams with adler-32 checking.
-
-     Limitations:
-      The callback API's are not implemented yet. No support for gzip
-   headers or zlib static dictionaries. I've tried to closely emulate
-   zlib's various flavors of stream flushing and return status codes,
-   but there are no guarantees that miniz.c pulls this off perfectly.
-
-   * PNG writing: See the tdefl_write_image_to_png_file_in_memory()
-   function, originally written by Alex Evans. Supports 1-4
-   bytes/pixel images.
-
-   * ZIP archive API notes:
-
-     The ZIP archive API's where designed with simplicity and
-   efficiency in mind, with just enough abstraction to get the job
-   done with minimal fuss. There are simple API's to retrieve file
-   information, read files from existing archives, create new
-   archives, append new files to existing archives, or clone archive
-   data from one archive to another. It supports archives located in
-   memory or the heap, on disk (using stdio.h), or you can specify
-   custom file read/write callbacks.
-
-     - Archive reading: Just call this function to read a single file
-   from a disk archive:
-
-      void *mz_zip_extract_archive_file_to_heap(const char
-   *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint
-   zip_flags);
-
-     For more complex cases, use the "mz_zip_reader" functions. Upon
-   opening an archive, the entire central directory is located and
-   read as-is into memory, and subsequent file access only occurs when
-   reading individual files.
-
-     - Archives file scanning: The simple way is to use this function
-   to scan a loaded archive for a specific file:
-
-     int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char
-   *pName, const char *pComment, mz_uint flags);
-
-     The locate operation can optionally check file comments too,
-   which (as one example) can be used to identify multiple versions of
-   the same file in an archive. This function uses a simple linear
-   search through the central directory, so it's not very fast.
-
-     Alternately, you can iterate through all the files in an archive
-   (using mz_zip_reader_get_num_files()) and retrieve detailed info on
-   each file by calling mz_zip_reader_file_stat().
-
-     - Archive creation: Use the "mz_zip_writer" functions. The ZIP
-   writer immediately writes compressed file data to disk and builds
-   an exact image of the central directory in memory. The central
-   directory image is written all at once at the end of the archive
-   file when the archive is finalized.
-
-     The archive writer can optionally align each file's local header
-   and file data to any power of 2 alignment, which can be useful when
-   the archive will be read from optical media. Also, the writer
-   supports placing arbitrary data blobs at the very beginning of ZIP
-   archives. Archives written using either feature are still readable
-   by any ZIP tool.
-
-     - Archive appending: The simple way to add a single file to an
-   archive is to call this function:
-
-      mz_bool mz_zip_add_mem_to_archive_file_in_place(const char
-   *pZip_filename, const char *pArchive_name, const void *pBuf, size_t
-   buf_size, const void *pComment, mz_uint16 comment_size, mz_uint
-   level_and_flags);
-
-     The archive will be created if it doesn't already exist,
-   otherwise it'll be appended to. Note the appending is done in-place
-   and is not an atomic operation, so if something goes wrong during
-   the operation it's possible the archive could be left without a
-   central directory (although the local file headers and file data
-   will be fine, so the archive will be recoverable).
-
-     For more complex archive modification scenarios:
-     1. The safest way is to use a mz_zip_reader to read the existing
-   archive, cloning only those bits you want to preserve into a new
-   archive using using the mz_zip_writer_add_from_zip_reader()
-   function (which compiles the compressed file data as-is). When
-   you're done, delete the old archive and rename the newly written
-   archive, and you're done. This is safe but requires a bunch of
-   temporary disk space or heap memory.
-
-     2. Or, you can convert an mz_zip_reader in-place to an
-   mz_zip_writer using mz_zip_writer_init_from_reader(), append new
-   files as needed, then finalize the archive which will write an
-   updated central directory to the original archive. (This is
-   basically what mz_zip_add_mem_to_archive_file_in_place() does.)
-   There's a possibility that the archive's central directory could be
-   lost with this method if anything goes wrong, though.
-
-     - ZIP archive support limitations:
-     No spanning support. Extraction functions can only handle
-   unencrypted, stored or deflated files. Requires streams capable of
-   seeking.
-
-   * This is a header file library, like stb_image.c. To get only a
-   header file, either cut and paste the below header, or create
-   miniz.h, #define MINIZ_HEADER_FILE_ONLY, and then include miniz.c
-   from it.
-
-   * Important: For best perf. be sure to customize the below macros
-   for your target platform: #define
-   MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1 #define MINIZ_LITTLE_ENDIAN
-   1 #define MINIZ_HAS_64BIT_REGISTERS 1
-
-   * On platforms using glibc, Be sure to "#define _LARGEFILE64_SOURCE
-   1" before including miniz.c to ensure miniz uses the 64-bit
-   variants: fopen64(), stat64(), etc. Otherwise you won't be able to
-   process large files (i.e. 32-bit stat() fails for me on files >
-   0x7FFFFFFF bytes).
-*/
-
-#ifndef KIT_MINIZ_MINIZ_H
-#define KIT_MINIZ_MINIZ_H
-
-/* Defines to completely disable specific portions of miniz.c:
-   If all macros here are defined the only functionality remaining
-   will be CRC-32 and adler-32. */
-
-/* Define MINIZ_NO_STDIO to disable all usage and any functions which
- * rely on stdio for file I/O. */
-/*#define MINIZ_NO_STDIO */
-
-/* If MINIZ_NO_TIME is specified then the ZIP archive functions will
- * not be able to get the current time, or */
-/* get/set file times, and the C run-time funcs that get/set times
- * won't be called. */
-/* The current downside is the times written to your archives will be
- * from 1979. */
-/*#define MINIZ_NO_TIME */
-
-/* Define MINIZ_NO_DEFLATE_APIS to disable all compression API's. */
-/*#define MINIZ_NO_DEFLATE_APIS */
-
-/* Define MINIZ_NO_INFLATE_APIS to disable all decompression API's. */
-/*#define MINIZ_NO_INFLATE_APIS */
-
-/* Define MINIZ_NO_ARCHIVE_APIS to disable all ZIP archive API's. */
-/*#define MINIZ_NO_ARCHIVE_APIS */
-
-/* Define MINIZ_NO_ARCHIVE_WRITING_APIS to disable all writing related
- * ZIP archive API's. */
-/*#define MINIZ_NO_ARCHIVE_WRITING_APIS */
-
-/* Define MINIZ_NO_ZLIB_APIS to remove all ZLIB-style
- * compression/decompression API's. */
-/*#define MINIZ_NO_ZLIB_APIS */
-
-/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAME to disable zlib names, to
- * prevent conflicts against stock zlib. */
-/*#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES */
-
-/* Define MINIZ_NO_MALLOC to disable all calls to malloc, free, and
-   realloc. Note if MINIZ_NO_MALLOC is defined then the user must
-   always provide custom user alloc/free/realloc callbacks to the zlib
-   and archive API's, and a few stand-alone helper API's which don't
-   provide custom user
-   functions (such as tdefl_compress_mem_to_heap() and
-   tinfl_decompress_mem_to_heap()) won't work. */
-/*#define MINIZ_NO_MALLOC */
-
-#ifdef MINIZ_NO_INFLATE_APIS
-#  define MINIZ_NO_ARCHIVE_APIS
-#endif
-
-#ifdef MINIZ_NO_DEFLATE_APIS
-#  define MINIZ_NO_ARCHIVE_WRITING_APIS
-#endif
-
-#if defined(__TINYC__) && (defined(__linux) || defined(__linux__))
-/* TODO: Work around "error: include file 'sys\utime.h' when compiling
- * with tcc on Linux */
-#  define MINIZ_NO_TIME
-#endif
-
-#include "miniz_common.h"
-
-#include <stddef.h>
-
-#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_ARCHIVE_APIS)
-#  include <time.h>
-#endif
-
-#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || \
-    defined(__i386) || defined(__i486__) || defined(__i486) ||  \
-    defined(i386) || defined(__ia64__) || defined(__x86_64__)
-/* MINIZ_X86_OR_X64_CPU is only used to help set the below macros. */
-#  define MINIZ_X86_OR_X64_CPU 1
-#else
-#  define MINIZ_X86_OR_X64_CPU 0
-#endif
-
-/* Set MINIZ_LITTLE_ENDIAN only if not set */
-#if !defined(MINIZ_LITTLE_ENDIAN)
-#  if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
-
-#    if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-/* Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian. */
-#      define MINIZ_LITTLE_ENDIAN 1
-#    else
-#      define MINIZ_LITTLE_ENDIAN 0
-#    endif
-
-#  else
-
-#    if MINIZ_X86_OR_X64_CPU
-#      define MINIZ_LITTLE_ENDIAN 1
-#    else
-#      define MINIZ_LITTLE_ENDIAN 0
-#    endif
-
-#  endif
-#endif
-
-/* Using unaligned loads and stores causes errors when using UBSan */
-#if defined(__has_feature)
-#  if __has_feature(undefined_behavior_sanitizer)
-#    define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
-#  endif
-#endif
-
-/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES only if not set */
-#if !defined(MINIZ_USE_UNALIGNED_LOADS_AND_STORES)
-#  if MINIZ_X86_OR_X64_CPU
-/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit
- * efficient integer loads and stores from unaligned addresses. */
-#    define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
-#    define MINIZ_UNALIGNED_USE_MEMCPY
-#  else
-#    define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
-#  endif
-#endif
-
-#if defined(_M_X64) || defined(_WIN64) || defined(__MINGW64__) || \
-    defined(_LP64) || defined(__LP64__) || defined(__ia64__) ||   \
-    defined(__x86_64__)
-/* Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers
- * are reasonably fast (and don't involve compiler generated calls to
- * helper functions). */
-#  define MINIZ_HAS_64BIT_REGISTERS 1
-#else
-#  define MINIZ_HAS_64BIT_REGISTERS 0
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ------------------- zlib-style API Definitions. */
-
-/* For more compatibility with zlib, miniz.c uses unsigned long for
- * some parameters/struct members. Beware: mz_ulong can be either 32
- * or 64-bits! */
-typedef unsigned long mz_ulong;
-
-/* mz_free() internally uses the MZ_FREE() macro (which by default
- * calls free() unless you've modified the MZ_MALLOC macro) to release
- * a block allocated from the heap. */
-void mz_free(void *p);
-
-#define MZ_ADLER32_INIT (1)
-/* mz_adler32() returns the initial adler-32 value to use when called
- * with ptr==NULL. */
-mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr,
-                    size_t buf_len);
-
-#define MZ_CRC32_INIT (0)
-/* mz_crc32() returns the initial CRC-32 value to use when called with
- * ptr==NULL. */
-mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr,
-                  size_t buf_len);
-
-/* Compression strategies. */
-enum {
-  MZ_DEFAULT_STRATEGY = 0,
-  MZ_FILTERED         = 1,
-  MZ_HUFFMAN_ONLY     = 2,
-  MZ_RLE              = 3,
-  MZ_FIXED            = 4
-};
-
-/* Method */
-#define MZ_DEFLATED 8
-
-/* Compression levels: 0-9 are the standard zlib-style levels, 10 is
- * best possible compression (not zlib compatible, and may be very
- * slow), MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL. */
-enum {
-  MZ_NO_COMPRESSION      = 0,
-  MZ_BEST_SPEED          = 1,
-  MZ_BEST_COMPRESSION    = 9,
-  MZ_UBER_COMPRESSION    = 10,
-  MZ_DEFAULT_LEVEL       = 6,
-  MZ_DEFAULT_COMPRESSION = -1
-};
-
-#define MZ_VERSION "11.0.2"
-#define MZ_VERNUM 0xB002
-#define MZ_VER_MAJOR 11
-#define MZ_VER_MINOR 2
-#define MZ_VER_REVISION 0
-#define MZ_VER_SUBREVISION 0
-
-#ifndef MINIZ_NO_ZLIB_APIS
-
-/* Flush values. For typical usage you only need MZ_NO_FLUSH and
- * MZ_FINISH. The other values are for advanced use (refer to the zlib
- * docs). */
-enum {
-  MZ_NO_FLUSH      = 0,
-  MZ_PARTIAL_FLUSH = 1,
-  MZ_SYNC_FLUSH    = 2,
-  MZ_FULL_FLUSH    = 3,
-  MZ_FINISH        = 4,
-  MZ_BLOCK         = 5
-};
-
-/* Return status codes. MZ_PARAM_ERROR is non-standard. */
-enum {
-  MZ_OK            = 0,
-  MZ_STREAM_END    = 1,
-  MZ_NEED_DICT     = 2,
-  MZ_ERRNO         = -1,
-  MZ_STREAM_ERROR  = -2,
-  MZ_DATA_ERROR    = -3,
-  MZ_MEM_ERROR     = -4,
-  MZ_BUF_ERROR     = -5,
-  MZ_VERSION_ERROR = -6,
-  MZ_PARAM_ERROR   = -10000
-};
-
-/* Window bits */
-#  define MZ_DEFAULT_WINDOW_BITS 15
-
-struct mz_internal_state;
-
-/* Compression/decompression stream struct. */
-typedef struct mz_stream_s {
-  const unsigned char *next_in; /* pointer to next byte to read */
-  unsigned int avail_in; /* number of bytes available at next_in */
-  mz_ulong     total_in; /* total number of bytes consumed so far */
-
-  unsigned char *next_out; /* pointer to next byte to write */
-  unsigned int
-      avail_out; /* number of bytes that can be written to next_out */
-  mz_ulong total_out; /* total number of bytes produced so far */
-
-  char *msg; /* error msg (unused) */
-  struct mz_internal_state
-      *state; /* internal state, allocated by zalloc/zfree */
-
-  mz_alloc_func zalloc; /* optional heap allocation function (defaults
-                           to malloc) */
-  mz_free_func
-        zfree;  /* optional heap free function (defaults to free) */
-  void *opaque; /* heap alloc function user pointer */
-
-  int      data_type; /* data_type (unused) */
-  mz_ulong adler;     /* adler32 of the source or uncompressed data */
-  mz_ulong reserved;  /* not used */
-} mz_stream;
-
-typedef mz_stream *mz_streamp;
-
-/* Returns the version string of miniz.c. */
-const char *mz_version(void);
-
-#  ifndef MINIZ_NO_DEFLATE_APIS
-
-/* mz_deflateInit() initializes a compressor with default options: */
-/* Parameters: */
-/*  pStream must point to an initialized mz_stream struct. */
-/*  level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION]. */
-/*  level 1 enables a specially optimized compression function that's
- * been optimized purely for performance, not ratio. */
-/*  (This special func. is currently only enabled when
- * MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are
- * defined.) */
-/* Return values: */
-/*  MZ_OK on success. */
-/*  MZ_STREAM_ERROR if the stream is bogus. */
-/*  MZ_PARAM_ERROR if the input parameters are bogus. */
-/*  MZ_MEM_ERROR on out of memory. */
-int mz_deflateInit(mz_streamp pStream, int level);
-
-/* mz_deflateInit2() is like mz_deflate(), except with more control:
- */
-/* Additional parameters: */
-/*   method must be MZ_DEFLATED */
-/*   window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate
- * stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS
- * (raw deflate/no header or footer) */
-/*   mem_level must be between [1, 9] (it's checked but ignored by
- * miniz.c) */
-int mz_deflateInit2(mz_streamp pStream, int level, int method,
-                    int window_bits, int mem_level, int strategy);
-
-/* Quickly resets a compressor without having to reallocate anything.
- * Same as calling mz_deflateEnd() followed by
- * mz_deflateInit()/mz_deflateInit2(). */
-int mz_deflateReset(mz_streamp pStream);
-
-/* mz_deflate() compresses the input to output, consuming as much of
- * the input and producing as much output as possible. */
-/* Parameters: */
-/*   pStream is the stream to read from and write to. You must
- * initialize/update the next_in, avail_in, next_out, and avail_out
- * members. */
-/*   flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH,
- * MZ_FULL_FLUSH, or MZ_FINISH. */
-/* Return values: */
-/*   MZ_OK on success (when flushing, or if more input is needed but
- * not available, and/or there's more output to be written but the
- * output buffer is full). */
-/*   MZ_STREAM_END if all input has been consumed and all output bytes
- * have been written. Don't call mz_deflate() on the stream anymore.
- */
-/*   MZ_STREAM_ERROR if the stream is bogus. */
-/*   MZ_PARAM_ERROR if one of the parameters is invalid. */
-/*   MZ_BUF_ERROR if no forward progress is possible because the input
- * and/or output buffers are empty. (Fill up the input buffer or free
- * up some output space and try again.) */
-int mz_deflate(mz_streamp pStream, int flush);
-
-/* mz_deflateEnd() deinitializes a compressor: */
-/* Return values: */
-/*  MZ_OK on success. */
-/*  MZ_STREAM_ERROR if the stream is bogus. */
-int mz_deflateEnd(mz_streamp pStream);
-
-/* mz_deflateBound() returns a (very) conservative upper bound on the
- * amount of data that could be generated by deflate(), assuming flush
- * is set to only MZ_NO_FLUSH or MZ_FINISH. */
-mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);
-
-/* Single-call compression functions mz_compress() and mz_compress2():
- */
-/* Returns MZ_OK on success, or one of the error codes from
- * mz_deflate() on failure. */
-int mz_compress(unsigned char *pDest, mz_ulong *pDest_len,
-                const unsigned char *pSource, mz_ulong source_len);
-int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len,
-                 const unsigned char *pSource, mz_ulong source_len,
-                 int level);
-
-/* mz_compressBound() returns a (very) conservative upper bound on the
- * amount of data that could be generated by calling mz_compress(). */
-mz_ulong mz_compressBound(mz_ulong source_len);
-
-#  endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
-
-#  ifndef MINIZ_NO_INFLATE_APIS
-
-/* Initializes a decompressor. */
-int mz_inflateInit(mz_streamp pStream);
-
-/* mz_inflateInit2() is like mz_inflateInit() with an additional
- * option that controls the window size and whether or not the stream
- * has been wrapped with a zlib header/footer: */
-/* window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib
- * header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate). */
-int mz_inflateInit2(mz_streamp pStream, int window_bits);
-
-/* Quickly resets a compressor without having to reallocate anything.
- * Same as calling mz_inflateEnd() followed by
- * mz_inflateInit()/mz_inflateInit2(). */
-int mz_inflateReset(mz_streamp pStream);
-
-/* Decompresses the input stream to the output, consuming only as much
- * of the input as needed, and writing as much to the output as
- * possible. */
-/* Parameters: */
-/*   pStream is the stream to read from and write to. You must
- * initialize/update the next_in, avail_in, next_out, and avail_out
- * members. */
-/*   flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH. */
-/*   On the first call, if flush is MZ_FINISH it's assumed the input
- * and output buffers are both sized large enough to decompress the
- * entire stream in a single call (this is slightly faster). */
-/*   MZ_FINISH implies that there are no more source bytes available
- * beside what's already in the input buffer, and that the output
- * buffer is large enough to hold the rest of the decompressed data.
- */
-/* Return values: */
-/*   MZ_OK on success. Either more input is needed but not available,
- * and/or there's more output to be written but the output buffer is
- * full. */
-/*   MZ_STREAM_END if all needed input has been consumed and all
- * output bytes have been written. For zlib streams, the adler-32 of
- * the decompressed data has also been verified. */
-/*   MZ_STREAM_ERROR if the stream is bogus. */
-/*   MZ_DATA_ERROR if the deflate stream is invalid. */
-/*   MZ_PARAM_ERROR if one of the parameters is invalid. */
-/*   MZ_BUF_ERROR if no forward progress is possible because the input
- * buffer is empty but the inflater needs more input to continue, or
- * if the output buffer is not large enough. Call mz_inflate() again
- */
-/*   with more input data, or with more room in the output buffer
- * (except when using single call decompression, described above). */
-int mz_inflate(mz_streamp pStream, int flush);
-
-/* Deinitializes a decompressor. */
-int mz_inflateEnd(mz_streamp pStream);
-
-/* Single-call decompression. */
-/* Returns MZ_OK on success, or one of the error codes from
- * mz_inflate() on failure. */
-int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len,
-                  const unsigned char *pSource, mz_ulong source_len);
-int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len,
-                   const unsigned char *pSource,
-                   mz_ulong            *pSource_len);
-#  endif /*#ifndef MINIZ_NO_INFLATE_APIS*/
-
-/* Returns a string description of the specified error code, or NULL
- * if the error code is invalid. */
-const char *mz_error(int err);
-
-/* Redefine zlib-compatible names to miniz equivalents, so miniz.c can
- * be used as a drop-in replacement for the subset of zlib that
- * miniz.c supports. */
-/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAMES to disable zlib-compatibility
- * if you use zlib in the same project. */
-#  ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES
-typedef unsigned char Byte;
-typedef unsigned int  uInt;
-typedef mz_ulong      uLong;
-typedef Byte          Bytef;
-typedef uInt          uIntf;
-typedef char          charf;
-typedef int           intf;
-typedef void         *voidpf;
-typedef uLong         uLongf;
-typedef void         *voidp;
-typedef void *const   voidpc;
-#    define Z_NULL 0
-#    define Z_NO_FLUSH MZ_NO_FLUSH
-#    define Z_PARTIAL_FLUSH MZ_PARTIAL_FLUSH
-#    define Z_SYNC_FLUSH MZ_SYNC_FLUSH
-#    define Z_FULL_FLUSH MZ_FULL_FLUSH
-#    define Z_FINISH MZ_FINISH
-#    define Z_BLOCK MZ_BLOCK
-#    define Z_OK MZ_OK
-#    define Z_STREAM_END MZ_STREAM_END
-#    define Z_NEED_DICT MZ_NEED_DICT
-#    define Z_ERRNO MZ_ERRNO
-#    define Z_STREAM_ERROR MZ_STREAM_ERROR
-#    define Z_DATA_ERROR MZ_DATA_ERROR
-#    define Z_MEM_ERROR MZ_MEM_ERROR
-#    define Z_BUF_ERROR MZ_BUF_ERROR
-#    define Z_VERSION_ERROR MZ_VERSION_ERROR
-#    define Z_PARAM_ERROR MZ_PARAM_ERROR
-#    define Z_NO_COMPRESSION MZ_NO_COMPRESSION
-#    define Z_BEST_SPEED MZ_BEST_SPEED
-#    define Z_BEST_COMPRESSION MZ_BEST_COMPRESSION
-#    define Z_DEFAULT_COMPRESSION MZ_DEFAULT_COMPRESSION
-#    define Z_DEFAULT_STRATEGY MZ_DEFAULT_STRATEGY
-#    define Z_FILTERED MZ_FILTERED
-#    define Z_HUFFMAN_ONLY MZ_HUFFMAN_ONLY
-#    define Z_RLE MZ_RLE
-#    define Z_FIXED MZ_FIXED
-#    define Z_DEFLATED MZ_DEFLATED
-#    define Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS
-#    define alloc_func mz_alloc_func
-#    define free_func mz_free_func
-#    define internal_state mz_internal_state
-#    define z_stream mz_stream
-
-#    ifndef MINIZ_NO_DEFLATE_APIS
-#      define deflateInit mz_deflateInit
-#      define deflateInit2 mz_deflateInit2
-#      define deflateReset mz_deflateReset
-#      define deflate mz_deflate
-#      define deflateEnd mz_deflateEnd
-#      define deflateBound mz_deflateBound
-#      define compress mz_compress
-#      define compress2 mz_compress2
-#      define compressBound mz_compressBound
-#    endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
-
-#    ifndef MINIZ_NO_INFLATE_APIS
-#      define inflateInit mz_inflateInit
-#      define inflateInit2 mz_inflateInit2
-#      define inflateReset mz_inflateReset
-#      define inflate mz_inflate
-#      define inflateEnd mz_inflateEnd
-#      define uncompress mz_uncompress
-#      define uncompress2 mz_uncompress2
-#    endif /*#ifndef MINIZ_NO_INFLATE_APIS*/
-
-#    define crc32 mz_crc32
-#    define adler32 mz_adler32
-#    define MAX_WBITS 15
-#    define MAX_MEM_LEVEL 9
-#    define zError mz_error
-#    define ZLIB_VERSION MZ_VERSION
-#    define ZLIB_VERNUM MZ_VERNUM
-#    define ZLIB_VER_MAJOR MZ_VER_MAJOR
-#    define ZLIB_VER_MINOR MZ_VER_MINOR
-#    define ZLIB_VER_REVISION MZ_VER_REVISION
-#    define ZLIB_VER_SUBREVISION MZ_VER_SUBREVISION
-#    define zlibVersion mz_version
-#    define zlib_version mz_version()
-#  endif /* #ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES */
-
-#endif /* MINIZ_NO_ZLIB_APIS */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include "miniz_zip.h"
-
-#endif