diff --git a/eng/DotNetBuild.props b/eng/DotNetBuild.props
index 41bbcb453fda59..86f8ce3b0fff45 100644
--- a/eng/DotNetBuild.props
+++ b/eng/DotNetBuild.props
@@ -98,7 +98,7 @@
 
       <!-- Handle system libraries -->
       <UseSystemLibs Condition="'$(UseSystemLibs)' != ''">+$(UseSystemLibs)+</UseSystemLibs>
-      <InnerBuildArgs Condition="'$(PortableBuild)' != 'true'">$(InnerBuildArgs) --cmakeargs -DCLR_CMAKE_USE_SYSTEM_BROTLI=true</InnerBuildArgs>
+      <InnerBuildArgs Condition="$(UseSystemLibs.Contains('+brotli+'))">$(InnerBuildArgs) --cmakeargs -DCLR_CMAKE_USE_SYSTEM_BROTLI=true</InnerBuildArgs>
       <InnerBuildArgs Condition="$(UseSystemLibs.Contains('+libunwind+'))">$(InnerBuildArgs) --cmakeargs -DCLR_CMAKE_USE_SYSTEM_LIBUNWIND=true</InnerBuildArgs>
       <!-- TODO: llvm-libunwind -->
       <!-- TODO: LinuxTracepoints -->
diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets
index 55dedda8fdd16a..af68ed744c9d21 100644
--- a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets
+++ b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets
@@ -30,6 +30,9 @@ The .NET Foundation licenses this file to you under the MIT license.
 
     <PropertyGroup>
       <UseSystemZlib Condition="'$(UseSystemZlib)' == '' and !Exists('$(IlcFrameworkNativePath)libz.a')">true</UseSystemZlib>
+      <!-- Use libbrotlicommon.a as the sentinel for the three brotli libs. -->
+      <UseSystemBrotli Condition="'$(UseSystemBrotli)' == '' and !Exists('$(IlcFrameworkNativePath)libbrotlicommon.a')">true</UseSystemBrotli>
+
       <FullRuntimeName>libRuntime.WorkstationGC</FullRuntimeName>
       <FullRuntimeName Condition="'$(ServerGarbageCollection)' == 'true' or '$(IlcLinkServerGC)' == 'true'">libRuntime.ServerGC</FullRuntimeName>
 
@@ -169,6 +172,14 @@ The .NET Foundation licenses this file to you under the MIT license.
       <NativeLibrary Condition="'$(UseSystemZlib)' != 'true'" Include="$(IlcFrameworkNativePath)libz.a" />
     </ItemGroup>
 
+    <!-- brotli must be added after System.IO.Compression.Native and brotlicommon must be added last, order matters. -->
+    <ItemGroup Condition="'$(UseSystemBrotli)' != 'true'">
+      <NativeLibrary Include="$(IlcFrameworkNativePath)libbrotlienc.a" />
+      <NativeLibrary Include="$(IlcFrameworkNativePath)libbrotlidec.a" />
+      <NativeLibrary Include="$(IlcFrameworkNativePath)libbrotlicommon.a" />
+    </ItemGroup>
+
+
     <ItemGroup Condition="'$(StaticICULinking)' == 'true' and '$(NativeLib)' != 'Static' and '$(InvariantGlobalization)' != 'true'">
       <NativeLibrary Include="$(IntermediateOutputPath)libs/System.Globalization.Native/build/libSystem.Globalization.Native.a" />
       <DirectPInvoke Include="libSystem.Globalization.Native" />
@@ -182,11 +193,6 @@ The .NET Foundation licenses this file to you under the MIT license.
       <NativeSystemLibrary Include="crypto" />
     </ItemGroup>
 
-    <ItemGroup Condition="'$(UseSystemBrotli)' != 'false' and Exists('$(IlcSdkPath)nonportable.txt')">
-      <NativeSystemLibrary Include="brotlienc" />
-      <NativeSystemLibrary Include="brotlidec" />
-    </ItemGroup>
-
     <ItemGroup Condition="'$(StaticOpenSslLinking)' == 'true' and '$(NativeLib)' != 'Static'">
       <NativeLibrary Include="$(IntermediateOutputPath)libs/System.Security.Cryptography.Native/build/libSystem.Security.Cryptography.Native.OpenSsl.a" />
       <DirectPInvoke Include="libSystem.Security.Cryptography.Native.OpenSsl" />
@@ -211,6 +217,7 @@ The .NET Foundation licenses this file to you under the MIT license.
       <NativeSystemLibrary Include="swiftCore" Condition="'$(_IsApplePlatform)' == 'true'" />
       <NativeSystemLibrary Include="swiftFoundation" Condition="'$(_IsApplePlatform)' == 'true'" />
       <NativeSystemLibrary Include="z" Condition="'$(UseSystemZlib)' == 'true'" />
+      <NativeSystemLibrary Include="brotlienc;brotlidec;brotlicommon" Condition="'$(UseSystemBrotli)' == 'true'" />
       <NativeSystemLibrary Include="rt" Condition="'$(_IsApplePlatform)' != 'true' and '$(_linuxLibcFlavor)' != 'bionic'" />
       <NativeSystemLibrary Include="log" Condition="'$(_linuxLibcFlavor)' == 'bionic'" />
       <NativeSystemLibrary Include="icucore" Condition="'$(_IsApplePlatform)' == 'true'" />
diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Windows.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Windows.targets
index 9de4cad8db5da1..67a2686336514b 100644
--- a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Windows.targets
+++ b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Windows.targets
@@ -49,6 +49,9 @@ The .NET Foundation licenses this file to you under the MIT license.
       <NativeLibrary Include="$(IlcSdkPath)$(StandaloneGCSupportName)$(LibrarySuffix)" />
       <NativeLibrary Include="$(IlcSdkPath)aotminipal$(LibFileExt)" />
       <NativeLibrary Include="$(IlcSdkPath)zlibstatic$(LibFileExt)" />
+      <NativeLibrary Include="$(IlcSdkPath)brotlicommon$(LibFileExt)" />
+      <NativeLibrary Include="$(IlcSdkPath)brotlienc$(LibFileExt)" />
+      <NativeLibrary Include="$(IlcSdkPath)brotlidec$(LibFileExt)" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props
index 2cd3cf685d3359..0c00174fe0d063 100644
--- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props
+++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props
@@ -282,6 +282,13 @@
     <!-- zlib-specific files -->
     <PlatformManifestFileEntry Include="libz.a" IsNative="true" />
     <PlatformManifestFileEntry Include="zlibstatic.lib" IsNative="true" />
+    <!-- brotli-specific files -->
+    <PlatformManifestFileEntry Include="libbrotlienc.a" IsNative="true" />
+    <PlatformManifestFileEntry Include="libbrotlidec.a" IsNative="true" />
+    <PlatformManifestFileEntry Include="libbrotlicommon.a" IsNative="true" />
+    <PlatformManifestFileEntry Include="brotlienc.lib" IsNative="true" />
+    <PlatformManifestFileEntry Include="brotlidec.lib" IsNative="true" />
+    <PlatformManifestFileEntry Include="brotlicommon.lib" IsNative="true" />
   </ItemGroup>
 
  <ItemGroup>
diff --git a/src/mono/msbuild/android/build/AndroidBuild.targets b/src/mono/msbuild/android/build/AndroidBuild.targets
index 917aed88506697..db37ceaf98d0e2 100644
--- a/src/mono/msbuild/android/build/AndroidBuild.targets
+++ b/src/mono/msbuild/android/build/AndroidBuild.targets
@@ -203,14 +203,15 @@
       <ProfiledAOTProfilePaths Include="$(MibcFilePath)" />
     </ItemGroup>
 
-    <!-- 
-      In order for the runtime to work when static linking, we must supply 
+    <!--
+      In order for the runtime to work when static linking, we must supply
       a list of direct pinvokes otherwise the runtime will crash
     -->
     <ItemGroup Condition="'$(_IsLibraryMode)' == 'true'">
       <DirectPInvokes Include="libSystem.Native" />
       <DirectPInvokes Include="libSystem.IO.Compression.Native" />
       <DirectPInvokes Include="libSystem.Security.Cryptography.Native.Android" />
+      <DirectPInvokes Include="libbrotlienc;libbrotlidec" />
     </ItemGroup>
 
     <PropertyGroup>
diff --git a/src/mono/msbuild/apple/build/AppleBuild.targets b/src/mono/msbuild/apple/build/AppleBuild.targets
index 463bcac8622e98..a136da379cced3 100644
--- a/src/mono/msbuild/apple/build/AppleBuild.targets
+++ b/src/mono/msbuild/apple/build/AppleBuild.targets
@@ -10,12 +10,12 @@
   </PropertyGroup>
 
   <UsingTask Condition="'$(AppleGenerateAppBundle)' == 'true'"
-             TaskName="AppleAppBuilderTask" 
+             TaskName="AppleAppBuilderTask"
              AssemblyFile="$(AppleAppBuilderTasksAssemblyPath)" />
   <UsingTask Condition="'$(RunAOTCompilation)' == 'true'"
              TaskName="ILStrip"
              AssemblyFile="$(MonoTargetsTasksAssemblyPath)" />
-  <UsingTask TaskName="MonoTargetsTasks.MarshalingPInvokeScanner" 
+  <UsingTask TaskName="MonoTargetsTasks.MarshalingPInvokeScanner"
              AssemblyFile="$(MonoTargetsTasksAssemblyPath)" />
 
   <Import Condition="Exists('$(ILCompilerTargetsPath)') and '$(UseNativeAOTRuntime)' == 'true'"
@@ -23,7 +23,7 @@
   <Import Condition="Exists('$(ILLinkTargetsPath)') and '$(UseNativeAOTRuntime)' == 'true'"
           Project="$(ILLinkTargetsPath)" />
 
-  <Target Name="_CleanPublish" 
+  <Target Name="_CleanPublish"
           BeforeTargets="Build">
     <RemoveDir Directories="$(PublishDir)" />
   </Target>
@@ -196,7 +196,7 @@
         <_IsNative>false</_IsNative>
       </_AssembliesToBundleInternal>
 
-      <_AotInputAssemblies Include="@(_AssembliesToBundleInternal)" 
+      <_AotInputAssemblies Include="@(_AssembliesToBundleInternal)"
                            Condition="'%(_AssembliesToBundleInternal._InternalForceInterpret)' != 'true'">
         <AotArguments>$(AotArguments)</AotArguments>
         <ProcessArguments>$(ProcessArguments)</ProcessArguments>
@@ -205,7 +205,7 @@
       <_AOT_InternalForceInterpretAssemblies Include="@(_AssembliesToBundleInternal->WithMetadataValue('_InternalForceInterpret', 'true'))" />
       <_AssembliesToBundleInternal Remove="@(_AssembliesToBundleInternal)" />
     </ItemGroup>
-    
+
     <MakeDir Directories="$(_MobileIntermediateOutputPath)" />
 
     <PropertyGroup Condition="'$(iOSLikeDedup)' == 'true'">
@@ -228,8 +228,8 @@
       <_ExcludeFromAppDir Include="$(_iOSLikeDedupAssembly)" />
     </ItemGroup>
 
-    <!-- 
-      In order for the runtime to work when static linking, we must supply 
+    <!--
+      In order for the runtime to work when static linking, we must supply
       a list of direct pinvokes otherwise the runtime will crash
     -->
     <ItemGroup Condition="'$(_IsLibraryMode)' == 'true'">
@@ -237,6 +237,7 @@
       <DirectPInvokes Include="libSystem.IO.Compression.Native" />
       <DirectPInvokes Include="libSystem.Net.Security.Native" />
       <DirectPInvokes Include="libSystem.Security.Cryptography.Native.Apple" />
+      <DirectPInvokes Include="libbrotlienc;libbrotlidec" />
     </ItemGroup>
 
     <PropertyGroup>
@@ -274,7 +275,7 @@
   <Target Name="_AppleNativeAotCompile"
           DependsOnTargets="SetupProperties;ComputeIlcCompileInputs;IlcCompile;$(_IlcLibraryBuildDependsOn)" />
 
-  <Target Name="_AppleGenerateAppBundle" 
+  <Target Name="_AppleGenerateAppBundle"
           Condition="'$(AppleGenerateAppBundle)' == 'true'"
           DependsOnTargets="_AppleGenerateRuntimeConfig">
     <!-- Run App bundler, it uses AOT libs (if needed), link all native bits, compile simple UI (written in ObjC)
@@ -336,7 +337,7 @@
   </Target>
 
   <Target Name="_AfterAppleBuild">
-    
+
   </Target>
 
   <Target Name="_AppleGenerateRuntimeConfig"
@@ -355,4 +356,4 @@
         RuntimeConfigReservedProperties="@(_RuntimeConfigReservedProperties)">
     </RuntimeConfigParserTask>
   </Target>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/native/corehost/apphost/static/CMakeLists.txt b/src/native/corehost/apphost/static/CMakeLists.txt
index c013b3fcce0d71..25c1d55e7360cd 100644
--- a/src/native/corehost/apphost/static/CMakeLists.txt
+++ b/src/native/corehost/apphost/static/CMakeLists.txt
@@ -153,6 +153,10 @@ if(CLR_CMAKE_TARGET_WIN32)
         delayimp.lib
     )
 
+    # additional requirements for System.IO.Compression.Native
+    include(${CLR_SRC_NATIVE_DIR}/libs/System.IO.Compression.Native/extra_libs.cmake)
+    append_extra_compression_libs(NATIVE_LIBS)
+
     set(RUNTIMEINFO_LIB runtimeinfo)
 
 else()
diff --git a/src/native/external/brotli-version.txt b/src/native/external/brotli-version.txt
index 6842f9f3c8b3e2..3b16281fdd36ea 100644
--- a/src/native/external/brotli-version.txt
+++ b/src/native/external/brotli-version.txt
@@ -1,6 +1,5 @@
 1.1.0
 https://github.com/google/brotli/releases/tag/v1.1.0
 
-Copy the c/dec, c/enc, c/common, and c/include folders into the root and remove all other files.
-
-Apply https://github.com/google/brotli/commit/85d88cbfc2b742e0742286ec277b73bdbf7be433.patch
\ No newline at end of file
+Deleted tests, python, docs folders
+Apply https://github.com/google/brotli/commit/85d88cbfc2b742e0742286ec277b73bdbf7be433.patch
diff --git a/src/native/external/brotli.cmake b/src/native/external/brotli.cmake
index c8f1b153af3465..0b77dabbe07dd7 100644
--- a/src/native/external/brotli.cmake
+++ b/src/native/external/brotli.cmake
@@ -1,39 +1,32 @@
 # IMPORTANT: do not use add_compile_options(), add_definitions() or similar functions here since it will leak to the including projects
 
-include_directories(BEFORE "${CMAKE_CURRENT_LIST_DIR}/brotli/include")
+include(FetchContent)
 
-set (BROTLI_SOURCES_BASE
-    common/constants.c
-    common/context.c
-    common/dictionary.c
-    common/platform.c
-    common/shared_dictionary.c
-    common/transform.c
-    dec/bit_reader.c
-    dec/decode.c
-    dec/huffman.c
-    dec/state.c
-    enc/backward_references.c
-    enc/backward_references_hq.c
-    enc/bit_cost.c
-    enc/block_splitter.c
-    enc/brotli_bit_stream.c
-    enc/cluster.c
-    enc/command.c
-    enc/compound_dictionary.c
-    enc/compress_fragment.c
-    enc/compress_fragment_two_pass.c
-    enc/dictionary_hash.c
-    enc/encode.c
-    enc/encoder_dict.c
-    enc/entropy_encode.c
-    enc/fast_log.c
-    enc/histogram.c
-    enc/literal_cost.c
-    enc/memory.c
-    enc/metablock.c
-    enc/static_dict.c
-    enc/utf8_util.c
+FetchContent_Declare(
+    brotli
+    SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/brotli
 )
 
-addprefix(BROTLI_SOURCES "${CMAKE_CURRENT_LIST_DIR}/brotli" "${BROTLI_SOURCES_BASE}")
+set(BROTLI_DISABLE_TESTS ON)
+set(__CURRENT_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
+set(BUILD_SHARED_LIBS OFF)
+FetchContent_MakeAvailable(brotli)
+set(BUILD_SHARED_LIBS ${__CURRENT_BUILD_SHARED_LIBS})
+
+target_compile_options(brotlicommon PRIVATE $<$<COMPILE_LANG_AND_ID:C,MSVC>:/guard:cf>)
+target_compile_options(brotlienc PRIVATE $<$<COMPILE_LANG_AND_ID:C,MSVC>:/guard:cf>)
+target_compile_options(brotlidec PRIVATE $<$<COMPILE_LANG_AND_ID:C,MSVC>:/guard:cf>)
+target_compile_options(brotlienc PRIVATE $<$<COMPILE_LANG_AND_ID:C,Clang,AppleClang,GNU>:-Wno-implicit-fallthrough>)
+target_compile_options(brotlidec PRIVATE $<$<COMPILE_LANG_AND_ID:C,Clang,AppleClang,GNU>:-Wno-implicit-fallthrough>)
+
+# Even though we aren't building brotli as shared libraries, we still need to be able to export the symbols
+# from the brotli libraries so that they can be used by System.IO.Compression.
+# Since we link all of the static libraries into a single shared library, we need to define BROTLICOMMON_SHARED_COMPILATION
+# for all targets so brotlienc and brotlidec don't expect to link against a separate brotlicommon shared library.
+target_compile_definitions(brotlienc PRIVATE BROTLI_SHARED_COMPILATION BROTLIENC_SHARED_COMPILATION BROTLICOMMON_SHARED_COMPILATION)
+target_compile_definitions(brotlidec PRIVATE BROTLI_SHARED_COMPILATION BROTLIDEC_SHARED_COMPILATION BROTLICOMMON_SHARED_COMPILATION)
+target_compile_definitions(brotlicommon PRIVATE BROTLI_SHARED_COMPILATION BROTLICOMMON_SHARED_COMPILATION)
+
+# Don't build the brotli command line tool unless explicitly requested
+# (which we never do)
+set_target_properties(brotli PROPERTIES EXCLUDE_FROM_ALL ON)
diff --git a/src/native/external/brotli/BUILD.bazel b/src/native/external/brotli/BUILD.bazel
new file mode 100644
index 00000000000000..34e4a542121347
--- /dev/null
+++ b/src/native/external/brotli/BUILD.bazel
@@ -0,0 +1,159 @@
+# Description:
+#   Brotli is a generic-purpose lossless compression algorithm.
+
+load(":compiler_config_setting.bzl", "create_msvc_config")
+
+package(
+    default_visibility = ["//visibility:public"],
+)
+
+licenses(["notice"])  # MIT
+
+exports_files(["LICENSE"])
+
+config_setting(
+    name = "darwin",
+    values = {"cpu": "darwin"},
+    visibility = ["//visibility:public"],
+)
+
+config_setting(
+    name = "darwin_x86_64",
+    values = {"cpu": "darwin_x86_64"},
+    visibility = ["//visibility:public"],
+)
+
+config_setting(
+    name = "windows",
+    values = {"cpu": "x64_windows"},
+    visibility = ["//visibility:public"],
+)
+
+config_setting(
+    name = "windows_msvc",
+    values = {"cpu": "x64_windows_msvc"},
+    visibility = ["//visibility:public"],
+)
+
+config_setting(
+    name = "windows_msys",
+    values = {"cpu": "x64_windows_msys"},
+    visibility = ["//visibility:public"],
+)
+
+create_msvc_config()
+
+STRICT_C_OPTIONS = select({
+    ":msvc": [],
+    ":clang-cl": [
+        "/W4",
+        "-Wconversion",
+        "-Wlong-long",
+        "-Wmissing-declarations",
+        "-Wmissing-prototypes",
+        "-Wno-strict-aliasing",
+        "-Wshadow",
+        "-Wsign-compare",
+        "-Wno-sign-conversion",
+    ],
+    "//conditions:default": [
+        "--pedantic-errors",
+        "-Wall",
+        "-Wconversion",
+        "-Werror",
+        "-Wextra",
+        "-Wlong-long",
+        "-Wmissing-declarations",
+        "-Wmissing-prototypes",
+        "-Wno-strict-aliasing",
+        "-Wshadow",
+        "-Wsign-compare",
+    ],
+})
+
+filegroup(
+    name = "public_headers",
+    srcs = glob(["c/include/brotli/*.h"]),
+)
+
+filegroup(
+    name = "common_headers",
+    srcs = glob(["c/common/*.h"]),
+)
+
+filegroup(
+    name = "common_sources",
+    srcs = glob(["c/common/*.c"]),
+)
+
+filegroup(
+    name = "dec_headers",
+    srcs = glob(["c/dec/*.h"]),
+)
+
+filegroup(
+    name = "dec_sources",
+    srcs = glob(["c/dec/*.c"]),
+)
+
+filegroup(
+    name = "enc_headers",
+    srcs = glob(["c/enc/*.h"]),
+)
+
+filegroup(
+    name = "enc_sources",
+    srcs = glob(["c/enc/*.c"]),
+)
+
+cc_library(
+    name = "brotli_inc",
+    hdrs = [":public_headers"],
+    copts = STRICT_C_OPTIONS,
+    strip_include_prefix = "c/include",
+)
+
+cc_library(
+    name = "brotlicommon",
+    srcs = [":common_sources"],
+    hdrs = [":common_headers"],
+    copts = STRICT_C_OPTIONS,
+    deps = [":brotli_inc"],
+)
+
+cc_library(
+    name = "brotlidec",
+    srcs = [":dec_sources"],
+    hdrs = [":dec_headers"],
+    copts = STRICT_C_OPTIONS,
+    deps = [":brotlicommon"],
+)
+
+cc_library(
+    name = "brotlienc",
+    srcs = [":enc_sources"],
+    hdrs = [":enc_headers"],
+    copts = STRICT_C_OPTIONS,
+    linkopts = select({
+        ":clang-cl": [],
+        ":msvc": [],
+        "//conditions:default": ["-lm"],
+    }),
+    deps = [":brotlicommon"],
+)
+
+cc_binary(
+    name = "brotli",
+    srcs = ["c/tools/brotli.c"],
+    copts = STRICT_C_OPTIONS,
+    linkstatic = 1,
+    deps = [
+        ":brotlidec",
+        ":brotlienc",
+    ],
+)
+
+filegroup(
+    name = "dictionary",
+    srcs = ["c/common/dictionary.bin"],
+)
diff --git a/src/native/external/brotli/CHANGELOG.md b/src/native/external/brotli/CHANGELOG.md
new file mode 100644
index 00000000000000..91e5005edbe82e
--- /dev/null
+++ b/src/native/external/brotli/CHANGELOG.md
@@ -0,0 +1,258 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+## [1.1.0] - 2023-08-28
+
+### Added
+ - decoder: `BrotliDecoderAttachDictionary`
+ - decoder: `BrotliDecoderOnFinish` callback behind `BROTLI_REPORTING`
+ - decoder: `BrotliDecoderSetMetadataCallbacks`
+ - encoder: `BrotliEncoderPrepareDictionary`,
+            `BrotliEncoderDestroyPreparedDictionary`,
+            `BrotliEncoderAttachPreparedDictionary`
+ - decoder: `BrotliEncoderOnFinish` callback behind `BROTLI_REPORTING`
+ - common: `BrotliSharedDictionaryCreateInstance`,
+           `BrotliSharedDictionaryDestroyInstance`,
+           `BrotliSharedDictionaryAttach`
+ - CLI: `--dictionary` option
+ - java: encoder wrapper: `Parameters.mode`
+ - java: `Brotli{Input|Output}Stream.attachDictionary`
+ - java: wrapper: partial byte array input
+ - typescript: decoder (transpiled from Java)
+
+### Removed
+ - build: `BROTLI_BUILD_PORTABLE` option
+
+### Fixed
+ - java: JNI decoder failed sometimes on power of 2 payloads
+
+### Improved
+ - java / js: smaller decoder footprint
+ - decoder: faster decoding
+ - encoder: faster encoding
+ - encoder: smaller stack frames
+
+
+## [1.0.9] - 2020-08-27
+
+Re-release of 1.0.8.
+
+
+## [1.0.8] - 2020-08-27
+
+### SECURITY
+ - CVE-2020-8927: potential overflow when input chunk is >2GiB
+
+### Added
+ - encoder: `BROTLI_PARAM_STREAM_OFFSET`
+
+### Improved
+ - CLI: better reporting
+ - CLI: workaround for "lying feof"
+ - java: faster decoding
+ - java: support "large window"
+ - encoder: use less memory
+ - release: filter sources for the tarball
+
+
+## [1.0.7] - 2018-10-23
+
+### Improved
+ - decoder: faster decoding on ARM CPU
+
+
+## [1.0.6] - 2018-09-13
+
+### Fixed
+ - build: AutoMake and CMake build
+ - java: JDK 8<->9 incompatibility
+
+
+## [1.0.5] - 2018-06-27
+
+### Added
+ - scripts: extraction of static dictionary from RFC
+
+### Improved
+ - encoder: better compression at quality 1
+ - encoder: better compression with "large window"
+
+
+## [1.0.4] - 2018-03-29
+
+### Added
+ - encoder: `BROTLI_PARAM_NPOSTFIX`, `BROTLI_PARAM_NDIRECT`
+ - CLI: `--large_window` option
+
+### Improved
+ - encoder: better compression
+
+
+## [1.0.3] - 2018-03-02
+
+### Added
+ - decoder: `BROTLI_DECODER_PARAM_LARGE_WINDOW` enum
+ - encoder: `BROTLI_PARAM_LARGE_WINDOW` enum
+ - java: `BrotliInputStream.setEager`
+
+### Fixed
+ - build: AutoMake build in some environments
+ - encoder: fix one-shot q=10 1-byte input compression
+
+### Improved
+ - encoder: better font compression
+
+
+## [1.0.2] - 2017-11-28
+
+### Added
+ - build: AutoMake
+ - research: better dictionary generators
+
+
+## [1.0.1] - 2017-09-22
+
+### Changed
+ - clarifications in `README.md`
+
+
+## [1.0.0] - 2017-09-20
+
+### Added
+ - decoder: `BrotliDecoderSetParameter`
+ - csharp: decoder (transpiled from Java)
+ - java: JNI wrappers
+ - javascript: decoder (transpiled from Java)
+ - python: streaming decompression
+ - research: dictionary generator
+
+### Changed
+ - CLI: rename `bro` to `brotli`
+
+### Removed
+ - decoder: `BrotliDecoderSetCustomDictionary`
+ - encoder: `BrotliEncoderSetCustomDictionary`
+
+### Improved
+ - java: faster decoding
+ - encoder: faster compression
+
+
+## [0.6.0] - 2017-04-10
+
+### Added
+ - CLI: `--no-copy-stat option
+ - java: pure java decoder
+ - build: fuzzers
+ - research: `brotlidump` tool to explore brotli streams
+ - go: wrapper
+
+### Removed
+ - decoder: API with plain `Brotli` prefix
+
+### Deprecated
+ - encoder: `BrotliEncoderInputBlockSize`, `BrotliEncoderCopyInputToRingBuffer`,
+            `BrotliEncoderWriteData`
+
+### Improved
+ - encoder: faster compression
+ - encoder: denser compression
+ - decoder: faster decompression
+ - python: release GIL
+ - python: use zero-copy API
+
+
+## [0.5.2] - 2016-08-11
+
+### Added
+ - common: `BROTLI_BOOL`, `BROTLI_TRUE`, `BROTLI_FALSE`
+ - decoder: API with `BrotliDecoder` prefix instead of plain `Brotli`
+ - build: Bazel, CMake
+
+### Deprecated
+ - decoder: API with plain `Brotli` prefix
+
+### Changed
+ - boolean argument / result types are re-branded as `BROTLI_BOOL`
+
+### Improved
+ - build: reduced amount of warnings in various build environments
+ - encoder: faster compression
+ - encoder: lower memory usage
+
+
+## [0.5.0] - 2016-06-15
+
+### Added
+ - common: library has been assembled from shared parts of decoder and encoder
+ - encoder: C API
+
+### Removed
+ - encoder: C++ API
+
+
+## [0.4.0] - 2016-06-14
+
+### Added
+ - encoder: faster compression modes (quality 0 and 1)
+ - decoder: `BrotliGetErrorCode`, `BrotliErrorString` and
+            `BROTLI_ERROR_CODES_LIST`
+
+### Removed
+ - decoder: deprecated streaming API (using `BrotliInput`)
+
+### Fixed
+ - decoder: possible pointer underflow
+
+### Improved
+ - encoder: faster compression
+
+
+## [0.3.0] - 2015-12-22
+
+### LICENSE
+License have been upgraded to more permissive MIT.
+
+### Added
+ - CLI: `--window` option
+ - `tools/version.h` file
+ - decoder: low level streaming API
+ - decoder: custom memory manager API
+
+### Deprecated
+ - decoder: streaming API using `BrotliInput` struct
+
+### Fixed
+ - decoder: processing of uncompressed blocks
+ - encoder: possible division by zero
+
+### Improved
+ - encoder: faster decompression
+ - build: more portable builds for various CPU architectures
+
+
+## [0.2.0] - 2015-09-01
+
+### Added
+ - CLI: `--verbose` and `--repeat` options
+
+### Fixed
+ - decoder: processing of uncompressed blocks
+ - encoder: block stitching on quality 10 / 11
+
+### Improved
+ - build: CI/CD integration
+ - build: better test coverage
+ - encoder: better compression of UTF-8 content
+ - encoder: faster decompression
+
+
+## [0.1.0] - 2015-08-11
+
+Initial release.
diff --git a/src/native/external/brotli/CMakeLists.txt b/src/native/external/brotli/CMakeLists.txt
new file mode 100644
index 00000000000000..61378cdae31aa2
--- /dev/null
+++ b/src/native/external/brotli/CMakeLists.txt
@@ -0,0 +1,364 @@
+# Available CMake versions:
+#  - Ubuntu  20.04 LTS   : 3.16.3
+#  - Solaris 11.4 SRU 15 : 3.15
+cmake_minimum_required(VERSION 3.15)
+
+# Since this project's version is loaded from other files, this policy
+# will help suppress the warning generated by cmake.
+# This policy is set because we can't provide "VERSION" in "project" command.
+# Use `cmake --help-policy CMP0048` for more information.
+cmake_policy(SET CMP0048 NEW)
+project(brotli C)
+
+option(BUILD_SHARED_LIBS "Build shared libraries" ON)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to Release as none was specified.")
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
+else()
+  message(STATUS "Build type is '${CMAKE_BUILD_TYPE}'")
+endif()
+
+include(CheckCSourceCompiles)
+check_c_source_compiles(
+  "#if defined(__EMSCRIPTEN__)
+   int main() {return 0;}
+   #endif"
+  BROTLI_EMSCRIPTEN
+)
+if (BROTLI_EMSCRIPTEN)
+  message("-- Compiler is EMSCRIPTEN")
+else()
+  message("-- Compiler is not EMSCRIPTEN")
+endif()
+
+# If Brotli is being bundled in another project, we don't want to
+# install anything.  However, we want to let people override this, so
+# we'll use the BROTLI_BUNDLED_MODE variable to let them do that; just
+# set it to OFF in your project before you add_subdirectory(brotli).
+get_directory_property(BROTLI_PARENT_DIRECTORY PARENT_DIRECTORY)
+if(NOT DEFINED BROTLI_BUNDLED_MODE)
+  # Bundled mode hasn't been set one way or the other, set the default
+  # depending on whether or not we are the top-level project.
+  if(BROTLI_PARENT_DIRECTORY)
+    set(BROTLI_BUNDLED_MODE ON)
+  else()
+    set(BROTLI_BUNDLED_MODE OFF)
+  endif()
+endif()
+mark_as_advanced(BROTLI_BUNDLED_MODE)
+
+include(GNUInstallDirs)
+
+# Reads macro from .h file; it is expected to be a single-line define.
+function(read_macro PATH MACRO OUTPUT)
+  file(STRINGS ${PATH} _line REGEX "^#define +${MACRO} +(.+)$")
+  string(REGEX REPLACE "^#define +${MACRO} +(.+)$" "\\1" _val "${_line}")
+  set(${OUTPUT} ${_val} PARENT_SCOPE)
+endfunction(read_macro)
+
+# Version information
+read_macro("c/common/version.h" "BROTLI_VERSION_MAJOR" BROTLI_VERSION_MAJOR)
+read_macro("c/common/version.h" "BROTLI_VERSION_MINOR" BROTLI_VERSION_MINOR)
+read_macro("c/common/version.h" "BROTLI_VERSION_PATCH" BROTLI_VERSION_PATCH)
+set(BROTLI_VERSION "${BROTLI_VERSION_MAJOR}.${BROTLI_VERSION_MINOR}.${BROTLI_VERSION_PATCH}")
+mark_as_advanced(BROTLI_VERSION BROTLI_VERSION_MAJOR BROTLI_VERSION_MINOR BROTLI_VERSION_PATCH)
+
+# ABI Version information
+read_macro("c/common/version.h" "BROTLI_ABI_CURRENT" BROTLI_ABI_CURRENT)
+read_macro("c/common/version.h" "BROTLI_ABI_REVISION" BROTLI_ABI_REVISION)
+read_macro("c/common/version.h" "BROTLI_ABI_AGE" BROTLI_ABI_AGE)
+math(EXPR BROTLI_ABI_COMPATIBILITY "${BROTLI_ABI_CURRENT} - ${BROTLI_ABI_AGE}")
+mark_as_advanced(BROTLI_ABI_CURRENT BROTLI_ABI_REVISION BROTLI_ABI_AGE BROTLI_ABI_COMPATIBILITY)
+
+if (ENABLE_SANITIZER)
+  set(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -fsanitize=${ENABLE_SANITIZER}")
+  set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fsanitize=${ENABLE_SANITIZER}")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=${ENABLE_SANITIZER}")
+endif ()
+
+include(CheckFunctionExists)
+set(LIBM_LIBRARY)
+CHECK_FUNCTION_EXISTS(log2 LOG2_RES)
+if(NOT LOG2_RES)
+  set(orig_req_libs "${CMAKE_REQUIRED_LIBRARIES}")
+  set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES};m")
+  CHECK_FUNCTION_EXISTS(log2 LOG2_LIBM_RES)
+  if(LOG2_LIBM_RES)
+    set(LIBM_LIBRARY "m")
+    add_definitions(-DBROTLI_HAVE_LOG2=1)
+  else()
+    add_definitions(-DBROTLI_HAVE_LOG2=0)
+  endif()
+
+  set(CMAKE_REQUIRED_LIBRARIES "${orig_req_libs}")
+  unset(LOG2_LIBM_RES)
+  unset(orig_req_libs)
+else()
+  add_definitions(-DBROTLI_HAVE_LOG2=1)
+endif()
+unset(LOG2_RES)
+
+set(BROTLI_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/c/include")
+mark_as_advanced(BROTLI_INCLUDE_DIRS)
+
+set(BROTLI_LIBRARIES_CORE brotlienc brotlidec brotlicommon)
+set(BROTLI_LIBRARIES ${BROTLI_LIBRARIES_CORE} ${LIBM_LIBRARY})
+mark_as_advanced(BROTLI_LIBRARIES)
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  add_definitions(-DOS_LINUX)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+  add_definitions(-DOS_FREEBSD)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  add_definitions(-DOS_MACOSX)
+  set(CMAKE_MACOS_RPATH TRUE)
+  set(CMAKE_INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib")
+endif()
+
+if(BROTLI_EMSCRIPTEN)
+  set(BUILD_SHARED_LIBS OFF)
+endif()
+
+file(GLOB_RECURSE BROTLI_COMMON_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} c/common/*.c)
+add_library(brotlicommon ${BROTLI_COMMON_SOURCES})
+
+file(GLOB_RECURSE BROTLI_DEC_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} c/dec/*.c)
+add_library(brotlidec ${BROTLI_DEC_SOURCES})
+
+file(GLOB_RECURSE BROTLI_ENC_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} c/enc/*.c)
+add_library(brotlienc ${BROTLI_ENC_SOURCES})
+
+# Older CMake versions does not understand INCLUDE_DIRECTORIES property.
+include_directories(${BROTLI_INCLUDE_DIRS})
+
+if(BUILD_SHARED_LIBS)
+  foreach(lib ${BROTLI_LIBRARIES_CORE})
+    target_compile_definitions(${lib} PUBLIC "BROTLI_SHARED_COMPILATION" )
+    string(TOUPPER "${lib}" LIB)
+    set_target_properties (${lib} PROPERTIES DEFINE_SYMBOL "${LIB}_SHARED_COMPILATION")
+  endforeach()
+endif()
+
+foreach(lib ${BROTLI_LIBRARIES_CORE})
+  target_link_libraries(${lib} ${LIBM_LIBRARY})
+  set_property(TARGET ${lib} APPEND PROPERTY INCLUDE_DIRECTORIES ${BROTLI_INCLUDE_DIRS})
+  set_target_properties(${lib} PROPERTIES
+    VERSION "${BROTLI_ABI_COMPATIBILITY}.${BROTLI_ABI_AGE}.${BROTLI_ABI_REVISION}"
+    SOVERSION "${BROTLI_ABI_COMPATIBILITY}")
+  if(NOT BROTLI_EMSCRIPTEN)
+    set_target_properties(${lib} PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
+  endif()
+  set_property(TARGET ${lib} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES "$<BUILD_INTERFACE:${BROTLI_INCLUDE_DIRS}>")
+endforeach()
+
+if(NOT BROTLI_EMSCRIPTEN)
+target_link_libraries(brotlidec brotlicommon)
+target_link_libraries(brotlienc brotlicommon)
+endif()
+
+# For projects stuck on older versions of CMake, this will set the
+# BROTLI_INCLUDE_DIRS and BROTLI_LIBRARIES variables so they still
+# have a relatively easy way to use Brotli:
+#
+#   include_directories(${BROTLI_INCLUDE_DIRS})
+#   target_link_libraries(foo ${BROTLI_LIBRARIES})
+if(BROTLI_PARENT_DIRECTORY)
+  set(BROTLI_INCLUDE_DIRS "${BROTLI_INCLUDE_DIRS}" PARENT_SCOPE)
+  set(BROTLI_LIBRARIES "${BROTLI_LIBRARIES}" PARENT_SCOPE)
+endif()
+
+# Build the brotli executable
+add_executable(brotli c/tools/brotli.c)
+target_link_libraries(brotli ${BROTLI_LIBRARIES})
+
+# Installation
+if(NOT BROTLI_BUNDLED_MODE)
+  install(
+    TARGETS brotli
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+  )
+
+  install(
+    TARGETS ${BROTLI_LIBRARIES_CORE}
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+  )
+
+  install(
+    DIRECTORY ${BROTLI_INCLUDE_DIRS}/brotli
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  )
+endif()  # BROTLI_BUNDLED_MODE
+
+# Tests
+
+# If we're targeting Windows but not running on Windows, we need Wine
+# to run the tests...
+if(NOT BROTLI_DISABLE_TESTS)
+  if(WIN32 AND NOT CMAKE_HOST_WIN32)
+    find_program(BROTLI_WRAPPER NAMES wine)
+
+    if(NOT BROTLI_WRAPPER)
+      message(STATUS "wine not found, disabling tests")
+      set(BROTLI_DISABLE_TESTS TRUE)
+    endif()
+  endif()
+endif()
+
+# If our compiler is a cross-compiler that we know about (arm/aarch64),
+# then we need to use qemu to execute the tests.
+if(NOT BROTLI_DISABLE_TESTS)
+  if ("${CMAKE_C_COMPILER}" MATCHES "^.*/arm-linux-gnueabihf-.*$")
+    message(STATUS "Detected arm-linux-gnueabihf cross-compilation")
+    set(BROTLI_WRAPPER "qemu-arm")
+    set(BROTLI_WRAPPER_LD_PREFIX "/usr/arm-linux-gnueabihf")
+  endif()
+
+  if ("${CMAKE_C_COMPILER}" MATCHES "^.*/arm-linux-gnueabi-.*$")
+    message(STATUS "Detected arm-linux-gnueabi cross-compilation")
+    set(BROTLI_WRAPPER "qemu-arm")
+    set(BROTLI_WRAPPER_LD_PREFIX "/usr/arm-linux-gnueabi")
+  endif()
+
+  if ("${CMAKE_C_COMPILER}" MATCHES "^.*/aarch64-linux-gnu-.*$")
+    message(STATUS "Detected aarch64-linux-gnu cross-compilation")
+    set(BROTLI_WRAPPER "qemu-aarch64")
+    set(BROTLI_WRAPPER_LD_PREFIX "/usr/aarch64-linux-gnu")
+  endif()
+endif()
+
+if(NOT BROTLI_DISABLE_TESTS)
+  include(CTest)
+  enable_testing()
+
+  set(ROUNDTRIP_INPUTS
+    tests/testdata/alice29.txt
+    tests/testdata/asyoulik.txt
+    tests/testdata/lcet10.txt
+    tests/testdata/plrabn12.txt
+    c/enc/encode.c
+    c/common/dictionary.h
+    c/dec/decode.c)
+
+  foreach(INPUT ${ROUNDTRIP_INPUTS})
+    get_filename_component(OUTPUT_NAME "${INPUT}" NAME)
+
+    set(OUTPUT_FILE "${CMAKE_CURRENT_BINARY_DIR}/${OUTPUT_NAME}")
+    set(INPUT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/${INPUT}")
+
+    if (EXISTS "${INPUT_FILE}")
+      foreach(quality 1 6 9 11)
+        add_test(NAME "${BROTLI_TEST_PREFIX}roundtrip/${INPUT}/${quality}"
+          COMMAND "${CMAKE_COMMAND}"
+            -DBROTLI_WRAPPER=${BROTLI_WRAPPER}
+            -DBROTLI_WRAPPER_LD_PREFIX=${BROTLI_WRAPPER_LD_PREFIX}
+            -DBROTLI_CLI=$<TARGET_FILE:brotli>
+            -DQUALITY=${quality}
+            -DINPUT=${INPUT_FILE}
+            -DOUTPUT=${OUTPUT_FILE}.${quality}
+            -P ${CMAKE_CURRENT_SOURCE_DIR}/tests/run-roundtrip-test.cmake)
+      endforeach()
+    else()
+      message(WARNING "Test file ${INPUT} does not exist.")
+    endif()
+  endforeach()
+
+  file(GLOB_RECURSE
+    COMPATIBILITY_INPUTS
+    RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+    tests/testdata/*.compressed*)
+
+  foreach(INPUT ${COMPATIBILITY_INPUTS})
+    add_test(NAME "${BROTLI_TEST_PREFIX}compatibility/${INPUT}"
+      COMMAND "${CMAKE_COMMAND}"
+        -DBROTLI_WRAPPER=${BROTLI_WRAPPER}
+        -DBROTLI_WRAPPER_LD_PREFIX=${BROTLI_WRAPPER_LD_PREFIX}
+        -DBROTLI_CLI=$<TARGET_FILE:brotli>
+        -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/${INPUT}
+        -P ${CMAKE_CURRENT_SOURCE_DIR}/tests/run-compatibility-test.cmake)
+  endforeach()
+endif()
+
+# Generate a pkg-config files
+
+function(generate_pkg_config_path outvar path)
+  string(LENGTH "${path}" path_length)
+
+  set(path_args ${ARGV})
+  list(REMOVE_AT path_args 0 1)
+  list(LENGTH path_args path_args_remaining)
+
+  set("${outvar}" "${path}")
+
+  while(path_args_remaining GREATER 1)
+    list(GET path_args 0 name)
+    list(GET path_args 1 value)
+
+    get_filename_component(value_full "${value}" ABSOLUTE)
+    string(LENGTH "${value}" value_length)
+
+    if(path_length EQUAL value_length AND path STREQUAL value)
+      set("${outvar}" "\${${name}}")
+      break()
+    elseif(path_length GREATER value_length)
+      # We might be in a subdirectory of the value, but we have to be
+      # careful about a prefix matching but not being a subdirectory
+      # (for example, /usr/lib64 is not a subdirectory of /usr/lib).
+      # We'll do this by making sure the next character is a directory
+      # separator.
+      string(SUBSTRING "${path}" ${value_length} 1 sep)
+      if(sep STREQUAL "/")
+        string(SUBSTRING "${path}" 0 ${value_length} s)
+        if(s STREQUAL value)
+          string(SUBSTRING "${path}" "${value_length}" -1 suffix)
+          set("${outvar}" "\${${name}}${suffix}")
+          break()
+        endif()
+      endif()
+    endif()
+
+    list(REMOVE_AT path_args 0 1)
+    list(LENGTH path_args path_args_remaining)
+  endwhile()
+
+  set("${outvar}" "${${outvar}}" PARENT_SCOPE)
+endfunction(generate_pkg_config_path)
+
+function(transform_pc_file INPUT_FILE OUTPUT_FILE VERSION)
+  file(READ ${INPUT_FILE} TEXT)
+
+  set(PREFIX "${CMAKE_INSTALL_PREFIX}")
+  string(REGEX REPLACE "@prefix@" "${PREFIX}" TEXT ${TEXT})
+  string(REGEX REPLACE "@exec_prefix@" "${PREFIX}" TEXT ${TEXT})
+
+  generate_pkg_config_path(LIBDIR "${CMAKE_INSTALL_FULL_LIBDIR}" prefix "${PREFIX}")
+  string(REGEX REPLACE "@libdir@" "${LIBDIR}" TEXT ${TEXT})
+
+  generate_pkg_config_path(INCLUDEDIR "${CMAKE_INSTALL_FULL_INCLUDEDIR}" prefix "${PREFIX}")
+  string(REGEX REPLACE "@includedir@" "${INCLUDEDIR}" TEXT ${TEXT})
+
+  string(REGEX REPLACE "@PACKAGE_VERSION@" "${VERSION}" TEXT ${TEXT})
+
+  file(WRITE ${OUTPUT_FILE} ${TEXT})
+endfunction()
+
+transform_pc_file("scripts/libbrotlicommon.pc.in" "${CMAKE_CURRENT_BINARY_DIR}/libbrotlicommon.pc" "${BROTLI_VERSION}")
+
+transform_pc_file("scripts/libbrotlidec.pc.in" "${CMAKE_CURRENT_BINARY_DIR}/libbrotlidec.pc" "${BROTLI_VERSION}")
+
+transform_pc_file("scripts/libbrotlienc.pc.in" "${CMAKE_CURRENT_BINARY_DIR}/libbrotlienc.pc" "${BROTLI_VERSION}")
+
+if(NOT BROTLI_BUNDLED_MODE)
+  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libbrotlicommon.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libbrotlidec.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libbrotlienc.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+endif()  # BROTLI_BUNDLED_MODE
+
+if (ENABLE_COVERAGE STREQUAL "yes")
+  SETUP_TARGET_FOR_COVERAGE(coverage test coverage)
+endif ()
diff --git a/src/native/external/brotli/CONTRIBUTING.md b/src/native/external/brotli/CONTRIBUTING.md
new file mode 100644
index 00000000000000..b34ee15be1dcf0
--- /dev/null
+++ b/src/native/external/brotli/CONTRIBUTING.md
@@ -0,0 +1,32 @@
+Want to contribute? Great! First, read this page (including the small print at
+the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement]
+(https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use Github pull requests for this purpose.
+
+### Code style
+Code should follow applicable formatting and style guides described in
+[Google Style Guides](https://google.github.io/styleguide/). C code should be
+C89 compatible.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the [Software Grant and Corporate Contributor License Agreement]
+(https://cla.developers.google.com/about/google-corporate).
diff --git a/src/native/external/brotli/LICENSE b/src/native/external/brotli/LICENSE
new file mode 100644
index 00000000000000..33b7cdd2dbaedd
--- /dev/null
+++ b/src/native/external/brotli/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/src/native/external/brotli/MANIFEST.in b/src/native/external/brotli/MANIFEST.in
new file mode 100644
index 00000000000000..ff8d600656f309
--- /dev/null
+++ b/src/native/external/brotli/MANIFEST.in
@@ -0,0 +1,19 @@
+include CONTRIBUTING.md
+include c/common/*.c
+include c/common/*.h
+include c/dec/*.c
+include c/dec/*.h
+include c/enc/*.c
+include c/enc/*.h
+include c/include/brotli/*.h
+include LICENSE
+include MANIFEST.in
+include python/_brotli.cc
+include python/bro.py
+include python/brotli.py
+include python/README.md
+include python/tests/*
+include README.md
+include setup.py
+include tests/testdata/*
+include c/tools/brotli.c
diff --git a/src/native/external/brotli/README b/src/native/external/brotli/README
new file mode 100644
index 00000000000000..dea7291306fd2f
--- /dev/null
+++ b/src/native/external/brotli/README
@@ -0,0 +1,15 @@
+BROTLI DATA COMPRESSION LIBRARY
+
+Brotli is a generic-purpose lossless compression algorithm that compresses data
+using a combination of a modern variant of the LZ77 algorithm, Huffman coding
+and 2nd order context modeling, with a compression ratio comparable to the best
+currently available general-purpose compression methods. It is similar in speed
+with deflate but offers more dense compression.
+
+The specification of the Brotli Compressed Data Format is defined in RFC 7932
+https://tools.ietf.org/html/rfc7932
+
+Brotli is open-sourced under the MIT License, see the LICENSE file.
+
+Brotli mailing list:
+https://groups.google.com/forum/#!forum/brotli
diff --git a/src/native/external/brotli/README.md b/src/native/external/brotli/README.md
new file mode 100644
index 00000000000000..67bf4d94a04deb
--- /dev/null
+++ b/src/native/external/brotli/README.md
@@ -0,0 +1,95 @@
+<p align="center">
+  <img src="https://github.com/google/brotli/actions/workflows/build_test.yml/badge.svg" alt="GitHub Actions Build Status" href="https://github.com/google/brotli/actions?query=branch%3Amaster">
+  <img src="https://oss-fuzz-build-logs.storage.googleapis.com/badges/brotli.svg" alt="Fuzzing Status" href="https://oss-fuzz-build-logs.storage.googleapis.com/index.html#brotli">
+</p>
+<p align="center"><img src="https://brotli.org/brotli.svg" alt="Brotli" width="64"></p>
+
+### Introduction
+
+Brotli is a generic-purpose lossless compression algorithm that compresses data
+using a combination of a modern variant of the LZ77 algorithm, Huffman coding
+and 2nd order context modeling, with a compression ratio comparable to the best
+currently available general-purpose compression methods. It is similar in speed
+with deflate but offers more dense compression.
+
+The specification of the Brotli Compressed Data Format is defined in [RFC 7932](https://tools.ietf.org/html/rfc7932).
+
+Brotli is open-sourced under the MIT License, see the LICENSE file.
+
+> **Please note:** brotli is a "stream" format; it does not contain
+> meta-information, like checksums or uncompresssed data length. It is possible
+> to modify "raw" ranges of the compressed stream and the decoder will not
+> notice that.
+
+### Build instructions
+
+#### Vcpkg
+
+You can download and install brotli using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    ./vcpkg install brotli
+
+The brotli port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+#### Bazel
+
+See [Bazel](http://www.bazel.build/)
+
+#### CMake
+
+The basic commands to build and install brotli are:
+
+    $ mkdir out && cd out
+    $ cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=./installed ..
+    $ cmake --build . --config Release --target install
+
+You can use other [CMake](https://cmake.org/) configuration.
+
+#### Python
+
+To install the latest release of the Python module, run the following:
+
+    $ pip install brotli
+
+To install the tip-of-the-tree version, run:
+
+    $ pip install --upgrade git+https://github.com/google/brotli
+
+See the [Python readme](python/README.md) for more details on installing
+from source, development, and testing.
+
+### Contributing
+
+We glad to answer/library related questions in
+[brotli mailing list](https://groups.google.com/forum/#!forum/brotli).
+
+Regular issues / feature requests should be reported in
+[issue tracker](https://github.com/google/brotli/issues).
+
+For reporting vulnerability please read [SECURITY](SECURITY.md).
+
+For contributing changes please read [CONTRIBUTING](CONTRIBUTING.md).
+
+### Benchmarks
+* [Squash Compression Benchmark](https://quixdb.github.io/squash-benchmark/) / [Unstable Squash Compression Benchmark](https://quixdb.github.io/squash-benchmark/unstable/)
+* [Large Text Compression Benchmark](http://mattmahoney.net/dc/text.html)
+* [Lzturbo Benchmark](https://sites.google.com/site/powturbo/home/benchmark)
+
+### Related projects
+> **Disclaimer:** Brotli authors take no responsibility for the third party projects mentioned in this section.
+
+Independent [decoder](https://github.com/madler/brotli) implementation by Mark Adler, based entirely on format specification.
+
+JavaScript port of brotli [decoder](https://github.com/devongovett/brotli.js). Could be used directly via `npm install brotli`
+
+Hand ported [decoder / encoder](https://github.com/dominikhlbg/BrotliHaxe) in haxe by Dominik Homberger. Output source code: JavaScript, PHP, Python, Java and C#
+
+7Zip [plugin](https://github.com/mcmilk/7-Zip-Zstd)
+
+Dart [native bindings](https://github.com/thosakwe/brotli)
+
+Dart compression framework with [fast FFI-based Brotli implementation](https://pub.dev/documentation/es_compression/latest/brotli/brotli-library.html) with ready-to-use prebuilt binaries for Win/Linux/Mac
diff --git a/src/native/external/brotli/SECURITY.md b/src/native/external/brotli/SECURITY.md
new file mode 100644
index 00000000000000..c2a44c66667734
--- /dev/null
+++ b/src/native/external/brotli/SECURITY.md
@@ -0,0 +1,6 @@
+### Reporting
+
+To report a security issue, please use [https://g.co/vulnz](https://g.co/vulnz).
+We use g.co/vulnz for our intake, and do coordination and disclosure here on
+GitHub (including using GitHub Security Advisory). The Google Security Team will
+respond within 5 working days of your report on g.co/vulnz.
diff --git a/src/native/external/brotli/WORKSPACE.bazel b/src/native/external/brotli/WORKSPACE.bazel
new file mode 100644
index 00000000000000..c26ddf8dd07e7c
--- /dev/null
+++ b/src/native/external/brotli/WORKSPACE.bazel
@@ -0,0 +1,26 @@
+workspace(name = "org_brotli")
+
+local_repository(
+    name = "ignore_org_brotli_fuzz",
+    path = "c/fuzz",
+)
+
+local_repository(
+    name = "ignore_org_brotli_go",
+    path = "go",
+)
+
+local_repository(
+    name = "ignore_org_brotli_java",
+    path = "java",
+)
+
+local_repository(
+    name = "ignore_org_brotli_js",
+    path = "js",
+)
+
+local_repository(
+    name = "ignore_org_brotli_research",
+    path = "research",
+)
diff --git a/src/native/external/brotli/common/constants.c b/src/native/external/brotli/c/common/constants.c
similarity index 100%
rename from src/native/external/brotli/common/constants.c
rename to src/native/external/brotli/c/common/constants.c
diff --git a/src/native/external/brotli/common/constants.h b/src/native/external/brotli/c/common/constants.h
similarity index 100%
rename from src/native/external/brotli/common/constants.h
rename to src/native/external/brotli/c/common/constants.h
diff --git a/src/native/external/brotli/common/context.c b/src/native/external/brotli/c/common/context.c
similarity index 100%
rename from src/native/external/brotli/common/context.c
rename to src/native/external/brotli/c/common/context.c
diff --git a/src/native/external/brotli/common/context.h b/src/native/external/brotli/c/common/context.h
similarity index 100%
rename from src/native/external/brotli/common/context.h
rename to src/native/external/brotli/c/common/context.h
diff --git a/src/native/external/brotli/common/dictionary.c b/src/native/external/brotli/c/common/dictionary.c
similarity index 100%
rename from src/native/external/brotli/common/dictionary.c
rename to src/native/external/brotli/c/common/dictionary.c
diff --git a/src/native/external/brotli/common/dictionary.h b/src/native/external/brotli/c/common/dictionary.h
similarity index 100%
rename from src/native/external/brotli/common/dictionary.h
rename to src/native/external/brotli/c/common/dictionary.h
diff --git a/src/native/external/brotli/common/platform.c b/src/native/external/brotli/c/common/platform.c
similarity index 100%
rename from src/native/external/brotli/common/platform.c
rename to src/native/external/brotli/c/common/platform.c
diff --git a/src/native/external/brotli/common/platform.h b/src/native/external/brotli/c/common/platform.h
similarity index 100%
rename from src/native/external/brotli/common/platform.h
rename to src/native/external/brotli/c/common/platform.h
diff --git a/src/native/external/brotli/common/shared_dictionary.c b/src/native/external/brotli/c/common/shared_dictionary.c
similarity index 100%
rename from src/native/external/brotli/common/shared_dictionary.c
rename to src/native/external/brotli/c/common/shared_dictionary.c
diff --git a/src/native/external/brotli/common/shared_dictionary_internal.h b/src/native/external/brotli/c/common/shared_dictionary_internal.h
similarity index 100%
rename from src/native/external/brotli/common/shared_dictionary_internal.h
rename to src/native/external/brotli/c/common/shared_dictionary_internal.h
diff --git a/src/native/external/brotli/common/transform.c b/src/native/external/brotli/c/common/transform.c
similarity index 100%
rename from src/native/external/brotli/common/transform.c
rename to src/native/external/brotli/c/common/transform.c
diff --git a/src/native/external/brotli/common/transform.h b/src/native/external/brotli/c/common/transform.h
similarity index 100%
rename from src/native/external/brotli/common/transform.h
rename to src/native/external/brotli/c/common/transform.h
diff --git a/src/native/external/brotli/common/version.h b/src/native/external/brotli/c/common/version.h
similarity index 100%
rename from src/native/external/brotli/common/version.h
rename to src/native/external/brotli/c/common/version.h
diff --git a/src/native/external/brotli/dec/bit_reader.c b/src/native/external/brotli/c/dec/bit_reader.c
similarity index 100%
rename from src/native/external/brotli/dec/bit_reader.c
rename to src/native/external/brotli/c/dec/bit_reader.c
diff --git a/src/native/external/brotli/dec/bit_reader.h b/src/native/external/brotli/c/dec/bit_reader.h
similarity index 100%
rename from src/native/external/brotli/dec/bit_reader.h
rename to src/native/external/brotli/c/dec/bit_reader.h
diff --git a/src/native/external/brotli/dec/decode.c b/src/native/external/brotli/c/dec/decode.c
similarity index 100%
rename from src/native/external/brotli/dec/decode.c
rename to src/native/external/brotli/c/dec/decode.c
diff --git a/src/native/external/brotli/dec/huffman.c b/src/native/external/brotli/c/dec/huffman.c
similarity index 100%
rename from src/native/external/brotli/dec/huffman.c
rename to src/native/external/brotli/c/dec/huffman.c
diff --git a/src/native/external/brotli/dec/huffman.h b/src/native/external/brotli/c/dec/huffman.h
similarity index 100%
rename from src/native/external/brotli/dec/huffman.h
rename to src/native/external/brotli/c/dec/huffman.h
diff --git a/src/native/external/brotli/dec/prefix.h b/src/native/external/brotli/c/dec/prefix.h
similarity index 100%
rename from src/native/external/brotli/dec/prefix.h
rename to src/native/external/brotli/c/dec/prefix.h
diff --git a/src/native/external/brotli/dec/state.c b/src/native/external/brotli/c/dec/state.c
similarity index 100%
rename from src/native/external/brotli/dec/state.c
rename to src/native/external/brotli/c/dec/state.c
diff --git a/src/native/external/brotli/dec/state.h b/src/native/external/brotli/c/dec/state.h
similarity index 100%
rename from src/native/external/brotli/dec/state.h
rename to src/native/external/brotli/c/dec/state.h
diff --git a/src/native/external/brotli/enc/backward_references.c b/src/native/external/brotli/c/enc/backward_references.c
similarity index 100%
rename from src/native/external/brotli/enc/backward_references.c
rename to src/native/external/brotli/c/enc/backward_references.c
diff --git a/src/native/external/brotli/enc/backward_references.h b/src/native/external/brotli/c/enc/backward_references.h
similarity index 100%
rename from src/native/external/brotli/enc/backward_references.h
rename to src/native/external/brotli/c/enc/backward_references.h
diff --git a/src/native/external/brotli/enc/backward_references_hq.c b/src/native/external/brotli/c/enc/backward_references_hq.c
similarity index 100%
rename from src/native/external/brotli/enc/backward_references_hq.c
rename to src/native/external/brotli/c/enc/backward_references_hq.c
diff --git a/src/native/external/brotli/enc/backward_references_hq.h b/src/native/external/brotli/c/enc/backward_references_hq.h
similarity index 100%
rename from src/native/external/brotli/enc/backward_references_hq.h
rename to src/native/external/brotli/c/enc/backward_references_hq.h
diff --git a/src/native/external/brotli/enc/backward_references_inc.h b/src/native/external/brotli/c/enc/backward_references_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/backward_references_inc.h
rename to src/native/external/brotli/c/enc/backward_references_inc.h
diff --git a/src/native/external/brotli/enc/bit_cost.c b/src/native/external/brotli/c/enc/bit_cost.c
similarity index 100%
rename from src/native/external/brotli/enc/bit_cost.c
rename to src/native/external/brotli/c/enc/bit_cost.c
diff --git a/src/native/external/brotli/enc/bit_cost.h b/src/native/external/brotli/c/enc/bit_cost.h
similarity index 100%
rename from src/native/external/brotli/enc/bit_cost.h
rename to src/native/external/brotli/c/enc/bit_cost.h
diff --git a/src/native/external/brotli/enc/bit_cost_inc.h b/src/native/external/brotli/c/enc/bit_cost_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/bit_cost_inc.h
rename to src/native/external/brotli/c/enc/bit_cost_inc.h
diff --git a/src/native/external/brotli/enc/block_encoder_inc.h b/src/native/external/brotli/c/enc/block_encoder_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/block_encoder_inc.h
rename to src/native/external/brotli/c/enc/block_encoder_inc.h
diff --git a/src/native/external/brotli/enc/block_splitter.c b/src/native/external/brotli/c/enc/block_splitter.c
similarity index 100%
rename from src/native/external/brotli/enc/block_splitter.c
rename to src/native/external/brotli/c/enc/block_splitter.c
diff --git a/src/native/external/brotli/enc/block_splitter.h b/src/native/external/brotli/c/enc/block_splitter.h
similarity index 100%
rename from src/native/external/brotli/enc/block_splitter.h
rename to src/native/external/brotli/c/enc/block_splitter.h
diff --git a/src/native/external/brotli/enc/block_splitter_inc.h b/src/native/external/brotli/c/enc/block_splitter_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/block_splitter_inc.h
rename to src/native/external/brotli/c/enc/block_splitter_inc.h
diff --git a/src/native/external/brotli/enc/brotli_bit_stream.c b/src/native/external/brotli/c/enc/brotli_bit_stream.c
similarity index 100%
rename from src/native/external/brotli/enc/brotli_bit_stream.c
rename to src/native/external/brotli/c/enc/brotli_bit_stream.c
diff --git a/src/native/external/brotli/enc/brotli_bit_stream.h b/src/native/external/brotli/c/enc/brotli_bit_stream.h
similarity index 100%
rename from src/native/external/brotli/enc/brotli_bit_stream.h
rename to src/native/external/brotli/c/enc/brotli_bit_stream.h
diff --git a/src/native/external/brotli/enc/cluster.c b/src/native/external/brotli/c/enc/cluster.c
similarity index 100%
rename from src/native/external/brotli/enc/cluster.c
rename to src/native/external/brotli/c/enc/cluster.c
diff --git a/src/native/external/brotli/enc/cluster.h b/src/native/external/brotli/c/enc/cluster.h
similarity index 100%
rename from src/native/external/brotli/enc/cluster.h
rename to src/native/external/brotli/c/enc/cluster.h
diff --git a/src/native/external/brotli/enc/cluster_inc.h b/src/native/external/brotli/c/enc/cluster_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/cluster_inc.h
rename to src/native/external/brotli/c/enc/cluster_inc.h
diff --git a/src/native/external/brotli/enc/command.c b/src/native/external/brotli/c/enc/command.c
similarity index 100%
rename from src/native/external/brotli/enc/command.c
rename to src/native/external/brotli/c/enc/command.c
diff --git a/src/native/external/brotli/enc/command.h b/src/native/external/brotli/c/enc/command.h
similarity index 100%
rename from src/native/external/brotli/enc/command.h
rename to src/native/external/brotli/c/enc/command.h
diff --git a/src/native/external/brotli/enc/compound_dictionary.c b/src/native/external/brotli/c/enc/compound_dictionary.c
similarity index 100%
rename from src/native/external/brotli/enc/compound_dictionary.c
rename to src/native/external/brotli/c/enc/compound_dictionary.c
diff --git a/src/native/external/brotli/enc/compound_dictionary.h b/src/native/external/brotli/c/enc/compound_dictionary.h
similarity index 100%
rename from src/native/external/brotli/enc/compound_dictionary.h
rename to src/native/external/brotli/c/enc/compound_dictionary.h
diff --git a/src/native/external/brotli/enc/compress_fragment.c b/src/native/external/brotli/c/enc/compress_fragment.c
similarity index 100%
rename from src/native/external/brotli/enc/compress_fragment.c
rename to src/native/external/brotli/c/enc/compress_fragment.c
diff --git a/src/native/external/brotli/enc/compress_fragment.h b/src/native/external/brotli/c/enc/compress_fragment.h
similarity index 100%
rename from src/native/external/brotli/enc/compress_fragment.h
rename to src/native/external/brotli/c/enc/compress_fragment.h
diff --git a/src/native/external/brotli/enc/compress_fragment_two_pass.c b/src/native/external/brotli/c/enc/compress_fragment_two_pass.c
similarity index 100%
rename from src/native/external/brotli/enc/compress_fragment_two_pass.c
rename to src/native/external/brotli/c/enc/compress_fragment_two_pass.c
diff --git a/src/native/external/brotli/enc/compress_fragment_two_pass.h b/src/native/external/brotli/c/enc/compress_fragment_two_pass.h
similarity index 100%
rename from src/native/external/brotli/enc/compress_fragment_two_pass.h
rename to src/native/external/brotli/c/enc/compress_fragment_two_pass.h
diff --git a/src/native/external/brotli/enc/dictionary_hash.c b/src/native/external/brotli/c/enc/dictionary_hash.c
similarity index 100%
rename from src/native/external/brotli/enc/dictionary_hash.c
rename to src/native/external/brotli/c/enc/dictionary_hash.c
diff --git a/src/native/external/brotli/enc/dictionary_hash.h b/src/native/external/brotli/c/enc/dictionary_hash.h
similarity index 100%
rename from src/native/external/brotli/enc/dictionary_hash.h
rename to src/native/external/brotli/c/enc/dictionary_hash.h
diff --git a/src/native/external/brotli/enc/encode.c b/src/native/external/brotli/c/enc/encode.c
similarity index 100%
rename from src/native/external/brotli/enc/encode.c
rename to src/native/external/brotli/c/enc/encode.c
diff --git a/src/native/external/brotli/enc/encoder_dict.c b/src/native/external/brotli/c/enc/encoder_dict.c
similarity index 100%
rename from src/native/external/brotli/enc/encoder_dict.c
rename to src/native/external/brotli/c/enc/encoder_dict.c
diff --git a/src/native/external/brotli/enc/encoder_dict.h b/src/native/external/brotli/c/enc/encoder_dict.h
similarity index 100%
rename from src/native/external/brotli/enc/encoder_dict.h
rename to src/native/external/brotli/c/enc/encoder_dict.h
diff --git a/src/native/external/brotli/enc/entropy_encode.c b/src/native/external/brotli/c/enc/entropy_encode.c
similarity index 100%
rename from src/native/external/brotli/enc/entropy_encode.c
rename to src/native/external/brotli/c/enc/entropy_encode.c
diff --git a/src/native/external/brotli/enc/entropy_encode.h b/src/native/external/brotli/c/enc/entropy_encode.h
similarity index 100%
rename from src/native/external/brotli/enc/entropy_encode.h
rename to src/native/external/brotli/c/enc/entropy_encode.h
diff --git a/src/native/external/brotli/enc/entropy_encode_static.h b/src/native/external/brotli/c/enc/entropy_encode_static.h
similarity index 100%
rename from src/native/external/brotli/enc/entropy_encode_static.h
rename to src/native/external/brotli/c/enc/entropy_encode_static.h
diff --git a/src/native/external/brotli/enc/fast_log.c b/src/native/external/brotli/c/enc/fast_log.c
similarity index 100%
rename from src/native/external/brotli/enc/fast_log.c
rename to src/native/external/brotli/c/enc/fast_log.c
diff --git a/src/native/external/brotli/enc/fast_log.h b/src/native/external/brotli/c/enc/fast_log.h
similarity index 100%
rename from src/native/external/brotli/enc/fast_log.h
rename to src/native/external/brotli/c/enc/fast_log.h
diff --git a/src/native/external/brotli/enc/find_match_length.h b/src/native/external/brotli/c/enc/find_match_length.h
similarity index 100%
rename from src/native/external/brotli/enc/find_match_length.h
rename to src/native/external/brotli/c/enc/find_match_length.h
diff --git a/src/native/external/brotli/enc/hash.h b/src/native/external/brotli/c/enc/hash.h
similarity index 100%
rename from src/native/external/brotli/enc/hash.h
rename to src/native/external/brotli/c/enc/hash.h
diff --git a/src/native/external/brotli/enc/hash_composite_inc.h b/src/native/external/brotli/c/enc/hash_composite_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/hash_composite_inc.h
rename to src/native/external/brotli/c/enc/hash_composite_inc.h
diff --git a/src/native/external/brotli/enc/hash_forgetful_chain_inc.h b/src/native/external/brotli/c/enc/hash_forgetful_chain_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/hash_forgetful_chain_inc.h
rename to src/native/external/brotli/c/enc/hash_forgetful_chain_inc.h
diff --git a/src/native/external/brotli/enc/hash_longest_match64_inc.h b/src/native/external/brotli/c/enc/hash_longest_match64_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/hash_longest_match64_inc.h
rename to src/native/external/brotli/c/enc/hash_longest_match64_inc.h
diff --git a/src/native/external/brotli/enc/hash_longest_match_inc.h b/src/native/external/brotli/c/enc/hash_longest_match_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/hash_longest_match_inc.h
rename to src/native/external/brotli/c/enc/hash_longest_match_inc.h
diff --git a/src/native/external/brotli/enc/hash_longest_match_quickly_inc.h b/src/native/external/brotli/c/enc/hash_longest_match_quickly_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/hash_longest_match_quickly_inc.h
rename to src/native/external/brotli/c/enc/hash_longest_match_quickly_inc.h
diff --git a/src/native/external/brotli/enc/hash_rolling_inc.h b/src/native/external/brotli/c/enc/hash_rolling_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/hash_rolling_inc.h
rename to src/native/external/brotli/c/enc/hash_rolling_inc.h
diff --git a/src/native/external/brotli/enc/hash_to_binary_tree_inc.h b/src/native/external/brotli/c/enc/hash_to_binary_tree_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/hash_to_binary_tree_inc.h
rename to src/native/external/brotli/c/enc/hash_to_binary_tree_inc.h
diff --git a/src/native/external/brotli/enc/histogram.c b/src/native/external/brotli/c/enc/histogram.c
similarity index 100%
rename from src/native/external/brotli/enc/histogram.c
rename to src/native/external/brotli/c/enc/histogram.c
diff --git a/src/native/external/brotli/enc/histogram.h b/src/native/external/brotli/c/enc/histogram.h
similarity index 100%
rename from src/native/external/brotli/enc/histogram.h
rename to src/native/external/brotli/c/enc/histogram.h
diff --git a/src/native/external/brotli/enc/histogram_inc.h b/src/native/external/brotli/c/enc/histogram_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/histogram_inc.h
rename to src/native/external/brotli/c/enc/histogram_inc.h
diff --git a/src/native/external/brotli/enc/literal_cost.c b/src/native/external/brotli/c/enc/literal_cost.c
similarity index 100%
rename from src/native/external/brotli/enc/literal_cost.c
rename to src/native/external/brotli/c/enc/literal_cost.c
diff --git a/src/native/external/brotli/enc/literal_cost.h b/src/native/external/brotli/c/enc/literal_cost.h
similarity index 100%
rename from src/native/external/brotli/enc/literal_cost.h
rename to src/native/external/brotli/c/enc/literal_cost.h
diff --git a/src/native/external/brotli/enc/memory.c b/src/native/external/brotli/c/enc/memory.c
similarity index 100%
rename from src/native/external/brotli/enc/memory.c
rename to src/native/external/brotli/c/enc/memory.c
diff --git a/src/native/external/brotli/enc/memory.h b/src/native/external/brotli/c/enc/memory.h
similarity index 100%
rename from src/native/external/brotli/enc/memory.h
rename to src/native/external/brotli/c/enc/memory.h
diff --git a/src/native/external/brotli/enc/metablock.c b/src/native/external/brotli/c/enc/metablock.c
similarity index 100%
rename from src/native/external/brotli/enc/metablock.c
rename to src/native/external/brotli/c/enc/metablock.c
diff --git a/src/native/external/brotli/enc/metablock.h b/src/native/external/brotli/c/enc/metablock.h
similarity index 100%
rename from src/native/external/brotli/enc/metablock.h
rename to src/native/external/brotli/c/enc/metablock.h
diff --git a/src/native/external/brotli/enc/metablock_inc.h b/src/native/external/brotli/c/enc/metablock_inc.h
similarity index 100%
rename from src/native/external/brotli/enc/metablock_inc.h
rename to src/native/external/brotli/c/enc/metablock_inc.h
diff --git a/src/native/external/brotli/enc/params.h b/src/native/external/brotli/c/enc/params.h
similarity index 100%
rename from src/native/external/brotli/enc/params.h
rename to src/native/external/brotli/c/enc/params.h
diff --git a/src/native/external/brotli/enc/prefix.h b/src/native/external/brotli/c/enc/prefix.h
similarity index 100%
rename from src/native/external/brotli/enc/prefix.h
rename to src/native/external/brotli/c/enc/prefix.h
diff --git a/src/native/external/brotli/enc/quality.h b/src/native/external/brotli/c/enc/quality.h
similarity index 100%
rename from src/native/external/brotli/enc/quality.h
rename to src/native/external/brotli/c/enc/quality.h
diff --git a/src/native/external/brotli/enc/ringbuffer.h b/src/native/external/brotli/c/enc/ringbuffer.h
similarity index 100%
rename from src/native/external/brotli/enc/ringbuffer.h
rename to src/native/external/brotli/c/enc/ringbuffer.h
diff --git a/src/native/external/brotli/enc/state.h b/src/native/external/brotli/c/enc/state.h
similarity index 100%
rename from src/native/external/brotli/enc/state.h
rename to src/native/external/brotli/c/enc/state.h
diff --git a/src/native/external/brotli/enc/static_dict.c b/src/native/external/brotli/c/enc/static_dict.c
similarity index 100%
rename from src/native/external/brotli/enc/static_dict.c
rename to src/native/external/brotli/c/enc/static_dict.c
diff --git a/src/native/external/brotli/enc/static_dict.h b/src/native/external/brotli/c/enc/static_dict.h
similarity index 100%
rename from src/native/external/brotli/enc/static_dict.h
rename to src/native/external/brotli/c/enc/static_dict.h
diff --git a/src/native/external/brotli/enc/static_dict_lut.h b/src/native/external/brotli/c/enc/static_dict_lut.h
similarity index 100%
rename from src/native/external/brotli/enc/static_dict_lut.h
rename to src/native/external/brotli/c/enc/static_dict_lut.h
diff --git a/src/native/external/brotli/enc/utf8_util.c b/src/native/external/brotli/c/enc/utf8_util.c
similarity index 100%
rename from src/native/external/brotli/enc/utf8_util.c
rename to src/native/external/brotli/c/enc/utf8_util.c
diff --git a/src/native/external/brotli/enc/utf8_util.h b/src/native/external/brotli/c/enc/utf8_util.h
similarity index 100%
rename from src/native/external/brotli/enc/utf8_util.h
rename to src/native/external/brotli/c/enc/utf8_util.h
diff --git a/src/native/external/brotli/enc/write_bits.h b/src/native/external/brotli/c/enc/write_bits.h
similarity index 100%
rename from src/native/external/brotli/enc/write_bits.h
rename to src/native/external/brotli/c/enc/write_bits.h
diff --git a/src/native/external/brotli/include/brotli/decode.h b/src/native/external/brotli/c/include/brotli/decode.h
similarity index 100%
rename from src/native/external/brotli/include/brotli/decode.h
rename to src/native/external/brotli/c/include/brotli/decode.h
diff --git a/src/native/external/brotli/include/brotli/encode.h b/src/native/external/brotli/c/include/brotli/encode.h
similarity index 100%
rename from src/native/external/brotli/include/brotli/encode.h
rename to src/native/external/brotli/c/include/brotli/encode.h
diff --git a/src/native/external/brotli/include/brotli/port.h b/src/native/external/brotli/c/include/brotli/port.h
similarity index 100%
rename from src/native/external/brotli/include/brotli/port.h
rename to src/native/external/brotli/c/include/brotli/port.h
diff --git a/src/native/external/brotli/include/brotli/shared_dictionary.h b/src/native/external/brotli/c/include/brotli/shared_dictionary.h
similarity index 100%
rename from src/native/external/brotli/include/brotli/shared_dictionary.h
rename to src/native/external/brotli/c/include/brotli/shared_dictionary.h
diff --git a/src/native/external/brotli/include/brotli/types.h b/src/native/external/brotli/c/include/brotli/types.h
similarity index 100%
rename from src/native/external/brotli/include/brotli/types.h
rename to src/native/external/brotli/c/include/brotli/types.h
diff --git a/src/native/external/brotli/c/tools/brotli.c b/src/native/external/brotli/c/tools/brotli.c
new file mode 100644
index 00000000000000..03f2d066ea6110
--- /dev/null
+++ b/src/native/external/brotli/c/tools/brotli.c
@@ -0,0 +1,1319 @@
+/* Copyright 2014 Google Inc. All Rights Reserved.
+
+   Distributed under MIT license.
+   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+*/
+
+/* Command line interface for Brotli library. */
+
+/* Mute strerror/strcpy warnings. */
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+
+#include <brotli/decode.h>
+#include <brotli/encode.h>
+#include <brotli/types.h>
+
+#include "../common/constants.h"
+#include "../common/version.h"
+
+#if defined(_WIN32)
+#include <io.h>
+#include <share.h>
+#include <sys/utime.h>
+
+#define MAKE_BINARY(FILENO) (_setmode((FILENO), _O_BINARY), (FILENO))
+
+#if !defined(__MINGW32__)
+#define STDIN_FILENO _fileno(stdin)
+#define STDOUT_FILENO _fileno(stdout)
+#define S_IRUSR S_IREAD
+#define S_IWUSR S_IWRITE
+#endif
+
+#define fdopen _fdopen
+#define isatty _isatty
+#define unlink _unlink
+#define utimbuf _utimbuf
+#define utime _utime
+
+#define fopen ms_fopen
+#define open ms_open
+
+#define chmod(F, P) (0)
+#define chown(F, O, G) (0)
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define fseek _fseeki64
+#define ftell _ftelli64
+#endif
+
+static FILE* ms_fopen(const char* filename, const char* mode) {
+  FILE* result = 0;
+  fopen_s(&result, filename, mode);
+  return result;
+}
+
+static int ms_open(const char* filename, int oflag, int pmode) {
+  int result = -1;
+  _sopen_s(&result, filename, oflag | O_BINARY, _SH_DENYNO, pmode);
+  return result;
+}
+#else  /* !defined(_WIN32) */
+#include <unistd.h>
+#include <utime.h>
+#define MAKE_BINARY(FILENO) (FILENO)
+#endif  /* defined(_WIN32) */
+
+#if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200809L)
+#define HAVE_UTIMENSAT 1
+#elif defined(_ATFILE_SOURCE)
+#define HAVE_UTIMENSAT 1
+#else
+#define HAVE_UTIMENSAT 0
+#endif
+
+#if HAVE_UTIMENSAT
+#if defined(__APPLE__)
+#define ATIME_NSEC(S) ((S)->st_atimespec.tv_nsec)
+#define MTIME_NSEC(S) ((S)->st_mtimespec.tv_nsec)
+#else  /* defined(__APPLE__) */
+#define ATIME_NSEC(S) ((S)->st_atim.tv_nsec)
+#define MTIME_NSEC(S) ((S)->st_mtim.tv_nsec)
+#endif
+#endif  /* HAVE_UTIMENSAT */
+
+typedef enum {
+  COMMAND_COMPRESS,
+  COMMAND_DECOMPRESS,
+  COMMAND_HELP,
+  COMMAND_INVALID,
+  COMMAND_TEST_INTEGRITY,
+  COMMAND_NOOP,
+  COMMAND_VERSION
+} Command;
+
+#define DEFAULT_LGWIN 24
+#define DEFAULT_SUFFIX ".br"
+#define MAX_OPTIONS 20
+
+typedef struct {
+  /* Parameters */
+  int quality;
+  int lgwin;
+  int verbosity;
+  BROTLI_BOOL force_overwrite;
+  BROTLI_BOOL junk_source;
+  BROTLI_BOOL reject_uncompressible;
+  BROTLI_BOOL copy_stat;
+  BROTLI_BOOL write_to_stdout;
+  BROTLI_BOOL test_integrity;
+  BROTLI_BOOL decompress;
+  BROTLI_BOOL large_window;
+  const char* output_path;
+  const char* dictionary_path;
+  const char* suffix;
+  int not_input_indices[MAX_OPTIONS];
+  size_t longest_path_len;
+  size_t input_count;
+
+  /* Inner state */
+  int argc;
+  char** argv;
+  uint8_t* dictionary;
+  size_t dictionary_size;
+  BrotliEncoderPreparedDictionary* prepared_dictionary;
+  char* modified_path;  /* Storage for path with appended / cut suffix */
+  int iterator;
+  int ignore;
+  BROTLI_BOOL iterator_error;
+  uint8_t* buffer;
+  uint8_t* input;
+  uint8_t* output;
+  const char* current_input_path;
+  const char* current_output_path;
+  int64_t input_file_length;  /* -1, if impossible to calculate */
+  FILE* fin;
+  FILE* fout;
+
+  /* I/O buffers */
+  size_t available_in;
+  const uint8_t* next_in;
+  size_t available_out;
+  uint8_t* next_out;
+
+  /* Reporting */
+  /* size_t would be large enough,
+     until 4GiB+ files are compressed / decompressed on 32-bit CPUs. */
+  size_t total_in;
+  size_t total_out;
+  clock_t start_time;
+  clock_t end_time;
+} Context;
+
+/* Parse up to 5 decimal digits. */
+static BROTLI_BOOL ParseInt(const char* s, int low, int high, int* result) {
+  int value = 0;
+  int i;
+  for (i = 0; i < 5; ++i) {
+    char c = s[i];
+    if (c == 0) break;
+    if (s[i] < '0' || s[i] > '9') return BROTLI_FALSE;
+    value = (10 * value) + (c - '0');
+  }
+  if (i == 0) return BROTLI_FALSE;
+  if (i > 1 && s[0] == '0') return BROTLI_FALSE;
+  if (s[i] != 0) return BROTLI_FALSE;
+  if (value < low || value > high) return BROTLI_FALSE;
+  *result = value;
+  return BROTLI_TRUE;
+}
+
+/* Returns "base file name" or its tail, if it contains '/' or '\'. */
+static const char* FileName(const char* path) {
+  const char* separator_position = strrchr(path, '/');
+  if (separator_position) path = separator_position + 1;
+  separator_position = strrchr(path, '\\');
+  if (separator_position) path = separator_position + 1;
+  return path;
+}
+
+/* Detect if the program name is a special alias that infers a command type. */
+static Command ParseAlias(const char* name) {
+  /* TODO: cast name to lower case? */
+  const char* unbrotli = "unbrotli";
+  size_t unbrotli_len = strlen(unbrotli);
+  name = FileName(name);
+  /* Partial comparison. On Windows there could be ".exe" suffix. */
+  if (strncmp(name, unbrotli, unbrotli_len) == 0) {
+    char terminator = name[unbrotli_len];
+    if (terminator == 0 || terminator == '.') return COMMAND_DECOMPRESS;
+  }
+  return COMMAND_COMPRESS;
+}
+
+static Command ParseParams(Context* params) {
+  int argc = params->argc;
+  char** argv = params->argv;
+  int i;
+  int next_option_index = 0;
+  size_t input_count = 0;
+  size_t longest_path_len = 1;
+  BROTLI_BOOL command_set = BROTLI_FALSE;
+  BROTLI_BOOL quality_set = BROTLI_FALSE;
+  BROTLI_BOOL output_set = BROTLI_FALSE;
+  BROTLI_BOOL keep_set = BROTLI_FALSE;
+  BROTLI_BOOL squash_set = BROTLI_FALSE;
+  BROTLI_BOOL lgwin_set = BROTLI_FALSE;
+  BROTLI_BOOL suffix_set = BROTLI_FALSE;
+  BROTLI_BOOL after_dash_dash = BROTLI_FALSE;
+  Command command = ParseAlias(argv[0]);
+
+  for (i = 1; i < argc; ++i) {
+    const char* arg = argv[i];
+    /* C99 5.1.2.2.1: "members argv[0] through argv[argc-1] inclusive shall
+       contain pointers to strings"; NULL and 0-length are not forbidden. */
+    size_t arg_len = arg ? strlen(arg) : 0;
+
+    if (arg_len == 0) {
+      params->not_input_indices[next_option_index++] = i;
+      continue;
+    }
+
+    /* Too many options. The expected longest option list is:
+       "-q 0 -w 10 -o f -D d -S b -d -f -k -n -v --", i.e. 16 items in total.
+       This check is an additional guard that is never triggered, but provides
+       a guard for future changes. */
+    if (next_option_index > (MAX_OPTIONS - 2)) {
+      fprintf(stderr, "too many options passed\n");
+      return COMMAND_INVALID;
+    }
+
+    /* Input file entry. */
+    if (after_dash_dash || arg[0] != '-' || arg_len == 1) {
+      input_count++;
+      if (longest_path_len < arg_len) longest_path_len = arg_len;
+      continue;
+    }
+
+    /* Not a file entry. */
+    params->not_input_indices[next_option_index++] = i;
+
+    /* '--' entry stop parsing arguments. */
+    if (arg_len == 2 && arg[1] == '-') {
+      after_dash_dash = BROTLI_TRUE;
+      continue;
+    }
+
+    /* Simple / coalesced options. */
+    if (arg[1] != '-') {
+      size_t j;
+      for (j = 1; j < arg_len; ++j) {
+        char c = arg[j];
+        if (c >= '0' && c <= '9') {
+          if (quality_set) {
+            fprintf(stderr, "quality already set\n");
+            return COMMAND_INVALID;
+          }
+          quality_set = BROTLI_TRUE;
+          params->quality = c - '0';
+          continue;
+        } else if (c == 'c') {
+          if (output_set) {
+            fprintf(stderr, "write to standard output already set\n");
+            return COMMAND_INVALID;
+          }
+          output_set = BROTLI_TRUE;
+          params->write_to_stdout = BROTLI_TRUE;
+          continue;
+        } else if (c == 'd') {
+          if (command_set) {
+            fprintf(stderr, "command already set when parsing -d\n");
+            return COMMAND_INVALID;
+          }
+          command_set = BROTLI_TRUE;
+          command = COMMAND_DECOMPRESS;
+          continue;
+        } else if (c == 'f') {
+          if (params->force_overwrite) {
+            fprintf(stderr, "force output overwrite already set\n");
+            return COMMAND_INVALID;
+          }
+          params->force_overwrite = BROTLI_TRUE;
+          continue;
+        } else if (c == 'h') {
+          /* Don't parse further. */
+          return COMMAND_HELP;
+        } else if (c == 'j' || c == 'k') {
+          if (keep_set) {
+            fprintf(stderr, "argument --rm / -j or --keep / -k already set\n");
+            return COMMAND_INVALID;
+          }
+          keep_set = BROTLI_TRUE;
+          params->junk_source = TO_BROTLI_BOOL(c == 'j');
+          continue;
+        } else if (c == 'n') {
+          if (!params->copy_stat) {
+            fprintf(stderr, "argument --no-copy-stat / -n already set\n");
+            return COMMAND_INVALID;
+          }
+          params->copy_stat = BROTLI_FALSE;
+          continue;
+        } else if (c == 's') {
+          if (squash_set) {
+            fprintf(stderr, "argument --squash / -s already set\n");
+            return COMMAND_INVALID;
+          }
+          squash_set = BROTLI_TRUE;
+          params->reject_uncompressible = BROTLI_TRUE;
+          continue;
+        } else if (c == 't') {
+          if (command_set) {
+            fprintf(stderr, "command already set when parsing -t\n");
+            return COMMAND_INVALID;
+          }
+          command_set = BROTLI_TRUE;
+          command = COMMAND_TEST_INTEGRITY;
+          continue;
+        } else if (c == 'v') {
+          if (params->verbosity > 0) {
+            fprintf(stderr, "argument --verbose / -v already set\n");
+            return COMMAND_INVALID;
+          }
+          params->verbosity = 1;
+          continue;
+        } else if (c == 'V') {
+          /* Don't parse further. */
+          return COMMAND_VERSION;
+        } else if (c == 'Z') {
+          if (quality_set) {
+            fprintf(stderr, "quality already set\n");
+            return COMMAND_INVALID;
+          }
+          quality_set = BROTLI_TRUE;
+          params->quality = 11;
+          continue;
+        }
+        /* o/q/w/D/S with parameter is expected */
+        if (c != 'o' && c != 'q' && c != 'w' && c != 'D' && c != 'S') {
+          fprintf(stderr, "invalid argument -%c\n", c);
+          return COMMAND_INVALID;
+        }
+        if (j + 1 != arg_len) {
+          fprintf(stderr, "expected parameter for argument -%c\n", c);
+          return COMMAND_INVALID;
+        }
+        i++;
+        if (i == argc || !argv[i] || argv[i][0] == 0) {
+          fprintf(stderr, "expected parameter for argument -%c\n", c);
+          return COMMAND_INVALID;
+        }
+        params->not_input_indices[next_option_index++] = i;
+        if (c == 'o') {
+          if (output_set) {
+            fprintf(stderr, "write to standard output already set (-o)\n");
+            return COMMAND_INVALID;
+          }
+          params->output_path = argv[i];
+        } else if (c == 'q') {
+          if (quality_set) {
+            fprintf(stderr, "quality already set\n");
+            return COMMAND_INVALID;
+          }
+          quality_set = ParseInt(argv[i], BROTLI_MIN_QUALITY,
+                                 BROTLI_MAX_QUALITY, &params->quality);
+          if (!quality_set) {
+            fprintf(stderr, "error parsing quality value [%s]\n", argv[i]);
+            return COMMAND_INVALID;
+          }
+        } else if (c == 'w') {
+          if (lgwin_set) {
+            fprintf(stderr, "lgwin parameter already set\n");
+            return COMMAND_INVALID;
+          }
+          lgwin_set = ParseInt(argv[i], 0,
+                               BROTLI_MAX_WINDOW_BITS, &params->lgwin);
+          if (!lgwin_set) {
+            fprintf(stderr, "error parsing lgwin value [%s]\n", argv[i]);
+            return COMMAND_INVALID;
+          }
+          if (params->lgwin != 0 && params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+            fprintf(stderr,
+                    "lgwin parameter (%d) smaller than the minimum (%d)\n",
+                    params->lgwin, BROTLI_MIN_WINDOW_BITS);
+            return COMMAND_INVALID;
+          }
+        } else if (c == 'D') {
+          if (params->dictionary_path) {
+            fprintf(stderr, "dictionary path already set\n");
+            return COMMAND_INVALID;
+          }
+          params->dictionary_path = argv[i];
+        } else if (c == 'S') {
+          if (suffix_set) {
+            fprintf(stderr, "suffix already set\n");
+            return COMMAND_INVALID;
+          }
+          suffix_set = BROTLI_TRUE;
+          params->suffix = argv[i];
+        }
+      }
+    } else {  /* Double-dash. */
+      arg = &arg[2];
+      if (strcmp("best", arg) == 0) {
+        if (quality_set) {
+          fprintf(stderr, "quality already set\n");
+          return COMMAND_INVALID;
+        }
+        quality_set = BROTLI_TRUE;
+        params->quality = 11;
+      } else if (strcmp("decompress", arg) == 0) {
+        if (command_set) {
+          fprintf(stderr, "command already set when parsing --decompress\n");
+          return COMMAND_INVALID;
+        }
+        command_set = BROTLI_TRUE;
+        command = COMMAND_DECOMPRESS;
+      } else if (strcmp("force", arg) == 0) {
+        if (params->force_overwrite) {
+          fprintf(stderr, "force output overwrite already set\n");
+          return COMMAND_INVALID;
+        }
+        params->force_overwrite = BROTLI_TRUE;
+      } else if (strcmp("help", arg) == 0) {
+        /* Don't parse further. */
+        return COMMAND_HELP;
+      } else if (strcmp("keep", arg) == 0) {
+        if (keep_set) {
+          fprintf(stderr, "argument --rm / -j or --keep / -k already set\n");
+          return COMMAND_INVALID;
+        }
+        keep_set = BROTLI_TRUE;
+        params->junk_source = BROTLI_FALSE;
+      } else if (strcmp("no-copy-stat", arg) == 0) {
+        if (!params->copy_stat) {
+          fprintf(stderr, "argument --no-copy-stat / -n already set\n");
+          return COMMAND_INVALID;
+        }
+        params->copy_stat = BROTLI_FALSE;
+      } else if (strcmp("rm", arg) == 0) {
+        if (keep_set) {
+          fprintf(stderr, "argument --rm / -j or --keep / -k already set\n");
+          return COMMAND_INVALID;
+        }
+        keep_set = BROTLI_TRUE;
+        params->junk_source = BROTLI_TRUE;
+      } else if (strcmp("squash", arg) == 0) {
+        if (squash_set) {
+          fprintf(stderr, "argument --squash / -s already set\n");
+          return COMMAND_INVALID;
+        }
+        squash_set = BROTLI_TRUE;
+        params->reject_uncompressible = BROTLI_TRUE;
+        continue;
+      } else if (strcmp("stdout", arg) == 0) {
+        if (output_set) {
+          fprintf(stderr, "write to standard output already set\n");
+          return COMMAND_INVALID;
+        }
+        output_set = BROTLI_TRUE;
+        params->write_to_stdout = BROTLI_TRUE;
+      } else if (strcmp("test", arg) == 0) {
+        if (command_set) {
+          fprintf(stderr, "command already set when parsing --test\n");
+          return COMMAND_INVALID;
+        }
+        command_set = BROTLI_TRUE;
+        command = COMMAND_TEST_INTEGRITY;
+      } else if (strcmp("verbose", arg) == 0) {
+        if (params->verbosity > 0) {
+          fprintf(stderr, "argument --verbose / -v already set\n");
+          return COMMAND_INVALID;
+        }
+        params->verbosity = 1;
+      } else if (strcmp("version", arg) == 0) {
+        /* Don't parse further. */
+        return COMMAND_VERSION;
+      } else {
+        /* key=value */
+        const char* value = strrchr(arg, '=');
+        size_t key_len;
+        if (!value || value[1] == 0) {
+          fprintf(stderr, "must pass the parameter as --%s=value\n", arg);
+          return COMMAND_INVALID;
+        }
+        key_len = (size_t)(value - arg);
+        value++;
+        if (strncmp("dictionary", arg, key_len) == 0) {
+          if (params->dictionary_path) {
+            fprintf(stderr, "dictionary path already set\n");
+            return COMMAND_INVALID;
+          }
+          params->dictionary_path = value;
+        } else if (strncmp("lgwin", arg, key_len) == 0) {
+          if (lgwin_set) {
+            fprintf(stderr, "lgwin parameter already set\n");
+            return COMMAND_INVALID;
+          }
+          lgwin_set = ParseInt(value, 0,
+                               BROTLI_MAX_WINDOW_BITS, &params->lgwin);
+          if (!lgwin_set) {
+            fprintf(stderr, "error parsing lgwin value [%s]\n", value);
+            return COMMAND_INVALID;
+          }
+          if (params->lgwin != 0 && params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+            fprintf(stderr,
+                    "lgwin parameter (%d) smaller than the minimum (%d)\n",
+                    params->lgwin, BROTLI_MIN_WINDOW_BITS);
+            return COMMAND_INVALID;
+          }
+        } else if (strncmp("large_window", arg, key_len) == 0) {
+          /* This option is intentionally not mentioned in help. */
+          if (lgwin_set) {
+            fprintf(stderr, "lgwin parameter already set\n");
+            return COMMAND_INVALID;
+          }
+          lgwin_set = ParseInt(value, 0,
+                               BROTLI_LARGE_MAX_WINDOW_BITS, &params->lgwin);
+          if (!lgwin_set) {
+            fprintf(stderr, "error parsing lgwin value [%s]\n", value);
+            return COMMAND_INVALID;
+          }
+          if (params->lgwin != 0 && params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+            fprintf(stderr,
+                    "lgwin parameter (%d) smaller than the minimum (%d)\n",
+                    params->lgwin, BROTLI_MIN_WINDOW_BITS);
+            return COMMAND_INVALID;
+          }
+        } else if (strncmp("output", arg, key_len) == 0) {
+          if (output_set) {
+            fprintf(stderr,
+                    "write to standard output already set (--output)\n");
+            return COMMAND_INVALID;
+          }
+          params->output_path = value;
+        } else if (strncmp("quality", arg, key_len) == 0) {
+          if (quality_set) {
+            fprintf(stderr, "quality already set\n");
+            return COMMAND_INVALID;
+          }
+          quality_set = ParseInt(value, BROTLI_MIN_QUALITY,
+                                 BROTLI_MAX_QUALITY, &params->quality);
+          if (!quality_set) {
+            fprintf(stderr, "error parsing quality value [%s]\n", value);
+            return COMMAND_INVALID;
+          }
+        } else if (strncmp("suffix", arg, key_len) == 0) {
+          if (suffix_set) {
+            fprintf(stderr, "suffix already set\n");
+            return COMMAND_INVALID;
+          }
+          suffix_set = BROTLI_TRUE;
+          params->suffix = value;
+        } else {
+          fprintf(stderr, "invalid parameter: [%s]\n", arg);
+          return COMMAND_INVALID;
+        }
+      }
+    }
+  }
+
+  params->input_count = input_count;
+  params->longest_path_len = longest_path_len;
+  params->decompress = (command == COMMAND_DECOMPRESS);
+  params->test_integrity = (command == COMMAND_TEST_INTEGRITY);
+
+  if (input_count > 1 && output_set) return COMMAND_INVALID;
+  if (params->test_integrity) {
+    if (params->output_path) return COMMAND_INVALID;
+    if (params->write_to_stdout) return COMMAND_INVALID;
+  }
+  if (params->reject_uncompressible && params->write_to_stdout) {
+    return COMMAND_INVALID;
+  }
+  if (strchr(params->suffix, '/') || strchr(params->suffix, '\\')) {
+    return COMMAND_INVALID;
+  }
+
+  return command;
+}
+
+static void PrintVersion(void) {
+  int major = BROTLI_VERSION_MAJOR;
+  int minor = BROTLI_VERSION_MINOR;
+  int patch = BROTLI_VERSION_PATCH;
+  fprintf(stdout, "brotli %d.%d.%d\n", major, minor, patch);
+}
+
+static void PrintHelp(const char* name, BROTLI_BOOL error) {
+  FILE* media = error ? stderr : stdout;
+  /* String is cut to pieces with length less than 509, to conform C90 spec. */
+  fprintf(media,
+"Usage: %s [OPTION]... [FILE]...\n",
+          name);
+  fprintf(media,
+"Options:\n"
+"  -#                          compression level (0-9)\n"
+"  -c, --stdout                write on standard output\n"
+"  -d, --decompress            decompress\n"
+"  -f, --force                 force output file overwrite\n"
+"  -h, --help                  display this help and exit\n");
+  fprintf(media,
+"  -j, --rm                    remove source file(s)\n"
+"  -s, --squash                remove destination file if larger than source\n"
+"  -k, --keep                  keep source file(s) (default)\n"
+"  -n, --no-copy-stat          do not copy source file(s) attributes\n"
+"  -o FILE, --output=FILE      output file (only if 1 input file)\n");
+  fprintf(media,
+"  -q NUM, --quality=NUM       compression level (%d-%d)\n",
+          BROTLI_MIN_QUALITY, BROTLI_MAX_QUALITY);
+  fprintf(media,
+"  -t, --test                  test compressed file integrity\n"
+"  -v, --verbose               verbose mode\n");
+  fprintf(media,
+"  -w NUM, --lgwin=NUM         set LZ77 window size (0, %d-%d)\n"
+"                              window size = 2**NUM - 16\n"
+"                              0 lets compressor choose the optimal value\n",
+          BROTLI_MIN_WINDOW_BITS, BROTLI_MAX_WINDOW_BITS);
+  fprintf(media,
+"  --large_window=NUM          use incompatible large-window brotli\n"
+"                              bitstream with window size (0, %d-%d)\n"
+"                              WARNING: this format is not compatible\n"
+"                              with brotli RFC 7932 and may not be\n"
+"                              decodable with regular brotli decoders\n",
+          BROTLI_MIN_WINDOW_BITS, BROTLI_LARGE_MAX_WINDOW_BITS);
+  fprintf(media,
+"  -D FILE, --dictionary=FILE  use FILE as raw (LZ77) dictionary\n");
+  fprintf(media,
+"  -S SUF, --suffix=SUF        output file suffix (default:'%s')\n",
+          DEFAULT_SUFFIX);
+  fprintf(media,
+"  -V, --version               display version and exit\n"
+"  -Z, --best                  use best compression level (11) (default)\n"
+"Simple options could be coalesced, i.e. '-9kf' is equivalent to '-9 -k -f'.\n"
+"With no FILE, or when FILE is -, read standard input.\n"
+"All arguments after '--' are treated as files.\n");
+}
+
+static const char* PrintablePath(const char* path) {
+  return path ? path : "con";
+}
+
+static BROTLI_BOOL OpenInputFile(const char* input_path, FILE** f) {
+  *f = NULL;
+  if (!input_path) {
+    *f = fdopen(MAKE_BINARY(STDIN_FILENO), "rb");
+    return BROTLI_TRUE;
+  }
+  *f = fopen(input_path, "rb");
+  if (!*f) {
+    fprintf(stderr, "failed to open input file [%s]: %s\n",
+            PrintablePath(input_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+static BROTLI_BOOL OpenOutputFile(const char* output_path, FILE** f,
+                                  BROTLI_BOOL force) {
+  int fd;
+  *f = NULL;
+  if (!output_path) {
+    *f = fdopen(MAKE_BINARY(STDOUT_FILENO), "wb");
+    return BROTLI_TRUE;
+  }
+  fd = open(output_path, O_CREAT | (force ? 0 : O_EXCL) | O_WRONLY | O_TRUNC,
+            S_IRUSR | S_IWUSR);
+  if (fd < 0) {
+    fprintf(stderr, "failed to open output file [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+  *f = fdopen(fd, "wb");
+  if (!*f) {
+    fprintf(stderr, "failed to open output file [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+static int64_t FileSize(const char* path) {
+  FILE* f = fopen(path, "rb");
+  int64_t retval;
+  if (f == NULL) {
+    return -1;
+  }
+  if (fseek(f, 0L, SEEK_END) != 0) {
+    fclose(f);
+    return -1;
+  }
+  retval = ftell(f);
+  if (fclose(f) != 0) {
+    return -1;
+  }
+  return retval;
+}
+
+static int CopyTimeStat(const struct stat* statbuf, const char* output_path) {
+#if HAVE_UTIMENSAT
+  struct timespec times[2];
+  times[0].tv_sec = statbuf->st_atime;
+  times[0].tv_nsec = ATIME_NSEC(statbuf);
+  times[1].tv_sec = statbuf->st_mtime;
+  times[1].tv_nsec = MTIME_NSEC(statbuf);
+  return utimensat(AT_FDCWD, output_path, times, AT_SYMLINK_NOFOLLOW);
+#else
+  struct utimbuf times;
+  times.actime = statbuf->st_atime;
+  times.modtime = statbuf->st_mtime;
+  return utime(output_path, &times);
+#endif
+}
+
+/* Copy file times and permissions.
+   TODO(eustas): this is a "best effort" implementation; honest cross-platform
+   fully featured implementation is way too hacky; add more hacks by request. */
+static void CopyStat(const char* input_path, const char* output_path) {
+  struct stat statbuf;
+  int res;
+  if (input_path == 0 || output_path == 0) {
+    return;
+  }
+  if (stat(input_path, &statbuf) != 0) {
+    return;
+  }
+  res = CopyTimeStat(&statbuf, output_path);
+  res = chmod(output_path, statbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
+  if (res != 0) {
+    fprintf(stderr, "setting access bits failed for [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+  }
+  res = chown(output_path, (uid_t)-1, statbuf.st_gid);
+  if (res != 0) {
+    fprintf(stderr, "setting group failed for [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+  }
+  res = chown(output_path, statbuf.st_uid, (gid_t)-1);
+  if (res != 0) {
+    fprintf(stderr, "setting user failed for [%s]: %s\n",
+            PrintablePath(output_path), strerror(errno));
+  }
+}
+
+/* Result ownership is passed to caller.
+   |*dictionary_size| is set to resulting buffer size. */
+static BROTLI_BOOL ReadDictionary(Context* context, Command command) {
+  static const int kMaxDictionarySize =
+      BROTLI_MAX_DISTANCE - BROTLI_MAX_BACKWARD_LIMIT(24);
+  FILE* f;
+  int64_t file_size_64;
+  uint8_t* buffer;
+  size_t bytes_read;
+
+  if (context->dictionary_path == NULL) return BROTLI_TRUE;
+  f = fopen(context->dictionary_path, "rb");
+  if (f == NULL) {
+    fprintf(stderr, "failed to open dictionary file [%s]: %s\n",
+            PrintablePath(context->dictionary_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+
+  file_size_64 = FileSize(context->dictionary_path);
+  if (file_size_64 == -1) {
+    fprintf(stderr, "could not get size of dictionary file [%s]",
+            PrintablePath(context->dictionary_path));
+    fclose(f);
+    return BROTLI_FALSE;
+  }
+
+  if (file_size_64 > kMaxDictionarySize) {
+    fprintf(stderr, "dictionary [%s] is larger than maximum allowed: %d\n",
+            PrintablePath(context->dictionary_path), kMaxDictionarySize);
+    fclose(f);
+    return BROTLI_FALSE;
+  }
+  context->dictionary_size = (size_t)file_size_64;
+
+  buffer = (uint8_t*)malloc(context->dictionary_size);
+  if (!buffer) {
+    fprintf(stderr, "could not read dictionary: out of memory\n");
+    fclose(f);
+    return BROTLI_FALSE;
+  }
+  bytes_read = fread(buffer, sizeof(uint8_t), context->dictionary_size, f);
+  if (bytes_read != context->dictionary_size) {
+    free(buffer);
+    fprintf(stderr, "failed to read dictionary [%s]: %s\n",
+            PrintablePath(context->dictionary_path), strerror(errno));
+    fclose(f);
+    return BROTLI_FALSE;
+  }
+  fclose(f);
+  context->dictionary = buffer;
+  if (command == COMMAND_COMPRESS) {
+    context->prepared_dictionary = BrotliEncoderPrepareDictionary(
+        BROTLI_SHARED_DICTIONARY_RAW, context->dictionary_size,
+        context->dictionary, BROTLI_MAX_QUALITY, NULL, NULL, NULL);
+    if (context->prepared_dictionary == NULL) {
+      fprintf(stderr, "failed to prepare dictionary [%s]\n",
+              PrintablePath(context->dictionary_path));
+      return BROTLI_FALSE;
+    }
+  }
+  return BROTLI_TRUE;
+}
+
+static BROTLI_BOOL NextFile(Context* context) {
+  const char* arg;
+  size_t arg_len;
+
+  /* Iterator points to last used arg; increment to search for the next one. */
+  context->iterator++;
+
+  context->input_file_length = -1;
+
+  /* No input path; read from console. */
+  if (context->input_count == 0) {
+    if (context->iterator > 1) return BROTLI_FALSE;
+    context->current_input_path = NULL;
+    /* Either write to the specified path, or to console. */
+    context->current_output_path = context->output_path;
+    return BROTLI_TRUE;
+  }
+
+  /* Skip option arguments. */
+  while (context->iterator == context->not_input_indices[context->ignore]) {
+    context->iterator++;
+    context->ignore++;
+  }
+
+  /* All args are scanned already. */
+  if (context->iterator >= context->argc) return BROTLI_FALSE;
+
+  /* Iterator now points to the input file name. */
+  arg = context->argv[context->iterator];
+  arg_len = strlen(arg);
+  /* Read from console. */
+  if (arg_len == 1 && arg[0] == '-') {
+    context->current_input_path = NULL;
+    context->current_output_path = context->output_path;
+    return BROTLI_TRUE;
+  }
+
+  context->current_input_path = arg;
+  context->input_file_length = FileSize(arg);
+  context->current_output_path = context->output_path;
+
+  if (context->output_path) return BROTLI_TRUE;
+  if (context->write_to_stdout) return BROTLI_TRUE;
+
+  strcpy(context->modified_path, arg);
+  context->current_output_path = context->modified_path;
+  /* If output is not specified, input path suffix should match. */
+  if (context->decompress) {
+    size_t suffix_len = strlen(context->suffix);
+    char* name = (char*)FileName(context->modified_path);
+    char* name_suffix;
+    size_t name_len = strlen(name);
+    if (name_len < suffix_len + 1) {
+      fprintf(stderr, "empty output file name for [%s] input file\n",
+              PrintablePath(arg));
+      context->iterator_error = BROTLI_TRUE;
+      return BROTLI_FALSE;
+    }
+    name_suffix = name + name_len - suffix_len;
+    if (strcmp(context->suffix, name_suffix) != 0) {
+      fprintf(stderr, "input file [%s] suffix mismatch\n",
+              PrintablePath(arg));
+      context->iterator_error = BROTLI_TRUE;
+      return BROTLI_FALSE;
+    }
+    name_suffix[0] = 0;
+    return BROTLI_TRUE;
+  } else {
+    strcpy(context->modified_path + arg_len, context->suffix);
+    return BROTLI_TRUE;
+  }
+}
+
+static BROTLI_BOOL OpenFiles(Context* context) {
+  BROTLI_BOOL is_ok = OpenInputFile(context->current_input_path, &context->fin);
+  if (!context->test_integrity && is_ok) {
+    is_ok = OpenOutputFile(
+        context->current_output_path, &context->fout, context->force_overwrite);
+  }
+  return is_ok;
+}
+
+static BROTLI_BOOL CloseFiles(Context* context, BROTLI_BOOL rm_input,
+                              BROTLI_BOOL rm_output) {
+  BROTLI_BOOL is_ok = BROTLI_TRUE;
+  if (!context->test_integrity && context->fout) {
+    if (fclose(context->fout) != 0) {
+      if (is_ok) {
+        fprintf(stderr, "fclose failed [%s]: %s\n",
+                PrintablePath(context->current_output_path), strerror(errno));
+      }
+      is_ok = BROTLI_FALSE;
+    }
+    if (rm_output && context->current_output_path) {
+      unlink(context->current_output_path);
+    }
+
+    /* TOCTOU violation, but otherwise it is impossible to set file times. */
+    if (!rm_output && is_ok && context->copy_stat) {
+      CopyStat(context->current_input_path, context->current_output_path);
+    }
+  }
+
+  if (context->fin) {
+    if (fclose(context->fin) != 0) {
+      if (is_ok) {
+        fprintf(stderr, "fclose failed [%s]: %s\n",
+                PrintablePath(context->current_input_path), strerror(errno));
+      }
+      is_ok = BROTLI_FALSE;
+    }
+  }
+  if (rm_input && context->current_input_path) {
+    unlink(context->current_input_path);
+  }
+
+  context->fin = NULL;
+  context->fout = NULL;
+
+  return is_ok;
+}
+
+static const size_t kFileBufferSize = 1 << 19;
+
+static void InitializeBuffers(Context* context) {
+  context->available_in = 0;
+  context->next_in = NULL;
+  context->available_out = kFileBufferSize;
+  context->next_out = context->output;
+  context->total_in = 0;
+  context->total_out = 0;
+  if (context->verbosity > 0) {
+    context->start_time = clock();
+  }
+}
+
+/* This method might give the false-negative result.
+   However, after an empty / incomplete read it should tell the truth. */
+static BROTLI_BOOL HasMoreInput(Context* context) {
+  return feof(context->fin) ? BROTLI_FALSE : BROTLI_TRUE;
+}
+
+static BROTLI_BOOL ProvideInput(Context* context) {
+  context->available_in =
+      fread(context->input, 1, kFileBufferSize, context->fin);
+  context->total_in += context->available_in;
+  context->next_in = context->input;
+  if (ferror(context->fin)) {
+    fprintf(stderr, "failed to read input [%s]: %s\n",
+            PrintablePath(context->current_input_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+/* Internal: should be used only in Provide-/Flush-Output. */
+static BROTLI_BOOL WriteOutput(Context* context) {
+  size_t out_size = (size_t)(context->next_out - context->output);
+  context->total_out += out_size;
+  if (out_size == 0) return BROTLI_TRUE;
+  if (context->test_integrity) return BROTLI_TRUE;
+
+  fwrite(context->output, 1, out_size, context->fout);
+  if (ferror(context->fout)) {
+    fprintf(stderr, "failed to write output [%s]: %s\n",
+            PrintablePath(context->current_output_path), strerror(errno));
+    return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+static BROTLI_BOOL ProvideOutput(Context* context) {
+  if (!WriteOutput(context)) return BROTLI_FALSE;
+  context->available_out = kFileBufferSize;
+  context->next_out = context->output;
+  return BROTLI_TRUE;
+}
+
+static BROTLI_BOOL FlushOutput(Context* context) {
+  if (!WriteOutput(context)) return BROTLI_FALSE;
+  context->available_out = 0;
+  return BROTLI_TRUE;
+}
+
+static void PrintBytes(size_t value) {
+  if (value < 1024) {
+    fprintf(stderr, "%d B", (int)value);
+  } else if (value < 1048576) {
+    fprintf(stderr, "%0.3f KiB", (double)value / 1024.0);
+  } else if (value < 1073741824) {
+    fprintf(stderr, "%0.3f MiB", (double)value / 1048576.0);
+  } else {
+    fprintf(stderr, "%0.3f GiB", (double)value / 1073741824.0);
+  }
+}
+
+static void PrintFileProcessingProgress(Context* context) {
+  fprintf(stderr, "[%s]: ", PrintablePath(context->current_input_path));
+  PrintBytes(context->total_in);
+  fprintf(stderr, " -> ");
+  PrintBytes(context->total_out);
+  fprintf(stderr, " in %1.2f sec", (double)(context->end_time - context->start_time) / CLOCKS_PER_SEC);
+}
+
+static const char* PrettyDecoderErrorString(BrotliDecoderErrorCode code) {
+  /* "_ERROR_domain_" is in only added in newer versions. If CLI is linked
+     against older shared library, return error string as is; result might be
+     a bit confusing, e.g. "RESERVED" instead of "FORMAT_RESERVED" */
+  const char* prefix = "_ERROR_";
+  size_t prefix_len = strlen(prefix);
+  const char* error_str = BrotliDecoderErrorString(code);
+  size_t error_len = strlen(error_str);
+  if (error_len > prefix_len) {
+    if (strncmp(error_str, prefix, prefix_len) == 0) {
+      error_str += prefix_len;
+    }
+  }
+  return error_str;
+}
+
+static BROTLI_BOOL DecompressFile(Context* context, BrotliDecoderState* s) {
+  BrotliDecoderResult result = BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
+  InitializeBuffers(context);
+  for (;;) {
+    if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
+      if (!HasMoreInput(context)) {
+        fprintf(stderr, "corrupt input [%s]\n",
+                PrintablePath(context->current_input_path));
+        if (context->verbosity > 0) {
+          fprintf(stderr, "reason: truncated input\n");
+        }
+        return BROTLI_FALSE;
+      }
+      if (!ProvideInput(context)) return BROTLI_FALSE;
+    } else if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
+      if (!ProvideOutput(context)) return BROTLI_FALSE;
+    } else if (result == BROTLI_DECODER_RESULT_SUCCESS) {
+      if (!FlushOutput(context)) return BROTLI_FALSE;
+      int has_more_input =
+          (context->available_in != 0) || (fgetc(context->fin) != EOF);
+      if (has_more_input) {
+        fprintf(stderr, "corrupt input [%s]\n",
+                PrintablePath(context->current_input_path));
+        if (context->verbosity > 0) {
+          fprintf(stderr, "reason: extra input\n");
+        }
+        return BROTLI_FALSE;
+      }
+      if (context->verbosity > 0) {
+        context->end_time = clock();
+        fprintf(stderr, "Decompressed ");
+        PrintFileProcessingProgress(context);
+        fprintf(stderr, "\n");
+      }
+      return BROTLI_TRUE;
+    } else {  /* result == BROTLI_DECODER_RESULT_ERROR */
+      fprintf(stderr, "corrupt input [%s]\n",
+              PrintablePath(context->current_input_path));
+      if (context->verbosity > 0) {
+        BrotliDecoderErrorCode error = BrotliDecoderGetErrorCode(s);
+        const char* error_str = PrettyDecoderErrorString(error);
+        fprintf(stderr, "reason: %s (%d)\n", error_str, error);
+      }
+      return BROTLI_FALSE;
+    }
+
+    result = BrotliDecoderDecompressStream(s, &context->available_in,
+        &context->next_in, &context->available_out, &context->next_out, 0);
+  }
+}
+
+static BROTLI_BOOL DecompressFiles(Context* context) {
+  while (NextFile(context)) {
+    BROTLI_BOOL is_ok = BROTLI_TRUE;
+    BROTLI_BOOL rm_input = BROTLI_FALSE;
+    BROTLI_BOOL rm_output = BROTLI_TRUE;
+    BrotliDecoderState* s = BrotliDecoderCreateInstance(NULL, NULL, NULL);
+    if (!s) {
+      fprintf(stderr, "out of memory\n");
+      return BROTLI_FALSE;
+    }
+    /* This allows decoding "large-window" streams. Though it creates
+       fragmentation (new builds decode streams that old builds don't),
+       it is better from used experience perspective. */
+    BrotliDecoderSetParameter(s, BROTLI_DECODER_PARAM_LARGE_WINDOW, 1u);
+    if (context->dictionary) {
+      BrotliDecoderAttachDictionary(s, BROTLI_SHARED_DICTIONARY_RAW,
+          context->dictionary_size, context->dictionary);
+    }
+    is_ok = OpenFiles(context);
+    if (is_ok && !context->current_input_path &&
+        !context->force_overwrite && isatty(STDIN_FILENO)) {
+      fprintf(stderr, "Use -h help. Use -f to force input from a terminal.\n");
+      is_ok = BROTLI_FALSE;
+    }
+    if (is_ok) is_ok = DecompressFile(context, s);
+    BrotliDecoderDestroyInstance(s);
+    rm_output = !is_ok;
+    rm_input = !rm_output && context->junk_source;
+    if (!CloseFiles(context, rm_input, rm_output)) is_ok = BROTLI_FALSE;
+    if (!is_ok) return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+static BROTLI_BOOL CompressFile(Context* context, BrotliEncoderState* s) {
+  BROTLI_BOOL is_eof = BROTLI_FALSE;
+  InitializeBuffers(context);
+  for (;;) {
+    if (context->available_in == 0 && !is_eof) {
+      if (!ProvideInput(context)) return BROTLI_FALSE;
+      is_eof = !HasMoreInput(context);
+    }
+
+    if (!BrotliEncoderCompressStream(s,
+        is_eof ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS,
+        &context->available_in, &context->next_in,
+        &context->available_out, &context->next_out, NULL)) {
+      /* Should detect OOM? */
+      fprintf(stderr, "failed to compress data [%s]\n",
+              PrintablePath(context->current_input_path));
+      return BROTLI_FALSE;
+    }
+
+    if (context->available_out == 0) {
+      if (!ProvideOutput(context)) return BROTLI_FALSE;
+    }
+
+    if (BrotliEncoderIsFinished(s)) {
+      if (!FlushOutput(context)) return BROTLI_FALSE;
+      if (context->verbosity > 0) {
+        context->end_time = clock();
+        fprintf(stderr, "Compressed ");
+        PrintFileProcessingProgress(context);
+        fprintf(stderr, "\n");
+      }
+      return BROTLI_TRUE;
+    }
+  }
+}
+
+static BROTLI_BOOL CompressFiles(Context* context) {
+  while (NextFile(context)) {
+    BROTLI_BOOL is_ok = BROTLI_TRUE;
+    BROTLI_BOOL rm_input = BROTLI_FALSE;
+    BROTLI_BOOL rm_output = BROTLI_TRUE;
+    BrotliEncoderState* s = BrotliEncoderCreateInstance(NULL, NULL, NULL);
+    if (!s) {
+      fprintf(stderr, "out of memory\n");
+      return BROTLI_FALSE;
+    }
+    BrotliEncoderSetParameter(s,
+        BROTLI_PARAM_QUALITY, (uint32_t)context->quality);
+    if (context->lgwin > 0) {
+      /* Specified by user. */
+      /* Do not enable "large-window" extension, if not required. */
+      if (context->lgwin > BROTLI_MAX_WINDOW_BITS) {
+        BrotliEncoderSetParameter(s, BROTLI_PARAM_LARGE_WINDOW, 1u);
+      }
+      BrotliEncoderSetParameter(s,
+          BROTLI_PARAM_LGWIN, (uint32_t)context->lgwin);
+    } else {
+      /* 0, or not specified by user; could be chosen by compressor. */
+      uint32_t lgwin = DEFAULT_LGWIN;
+      /* Use file size to limit lgwin. */
+      if (context->input_file_length >= 0) {
+        lgwin = BROTLI_MIN_WINDOW_BITS;
+        while (BROTLI_MAX_BACKWARD_LIMIT(lgwin) <
+               (uint64_t)context->input_file_length) {
+          lgwin++;
+          if (lgwin == BROTLI_MAX_WINDOW_BITS) break;
+        }
+      }
+      BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, lgwin);
+    }
+    if (context->input_file_length > 0) {
+      uint32_t size_hint = context->input_file_length < (1 << 30) ?
+          (uint32_t)context->input_file_length : (1u << 30);
+      BrotliEncoderSetParameter(s, BROTLI_PARAM_SIZE_HINT, size_hint);
+    }
+    if (context->dictionary) {
+      BrotliEncoderAttachPreparedDictionary(s, context->prepared_dictionary);
+    }
+    is_ok = OpenFiles(context);
+    if (is_ok && !context->current_output_path &&
+        !context->force_overwrite && isatty(STDOUT_FILENO)) {
+      fprintf(stderr, "Use -h help. Use -f to force output to a terminal.\n");
+      is_ok = BROTLI_FALSE;
+    }
+    if (is_ok) is_ok = CompressFile(context, s);
+    BrotliEncoderDestroyInstance(s);
+    rm_output = !is_ok;
+    if (is_ok && context->reject_uncompressible) {
+      if (context->total_out >= context->total_in) {
+        rm_output = BROTLI_TRUE;
+        if (context->verbosity > 0) {
+          fprintf(stderr, "Output is larger than input\n");
+        }
+      }
+    }
+    rm_input = !rm_output && context->junk_source;
+    if (!CloseFiles(context, rm_input, rm_output)) is_ok = BROTLI_FALSE;
+    if (!is_ok) return BROTLI_FALSE;
+  }
+  return BROTLI_TRUE;
+}
+
+int main(int argc, char** argv) {
+  Command command;
+  Context context;
+  BROTLI_BOOL is_ok = BROTLI_TRUE;
+  int i;
+
+  context.quality = 11;
+  context.lgwin = -1;
+  context.verbosity = 0;
+  context.force_overwrite = BROTLI_FALSE;
+  context.junk_source = BROTLI_FALSE;
+  context.reject_uncompressible = BROTLI_FALSE;
+  context.copy_stat = BROTLI_TRUE;
+  context.test_integrity = BROTLI_FALSE;
+  context.write_to_stdout = BROTLI_FALSE;
+  context.decompress = BROTLI_FALSE;
+  context.large_window = BROTLI_FALSE;
+  context.output_path = NULL;
+  context.dictionary_path = NULL;
+  context.suffix = DEFAULT_SUFFIX;
+  for (i = 0; i < MAX_OPTIONS; ++i) context.not_input_indices[i] = 0;
+  context.longest_path_len = 1;
+  context.input_count = 0;
+
+  context.argc = argc;
+  context.argv = argv;
+  context.dictionary = NULL;
+  context.dictionary_size = 0;
+  context.prepared_dictionary = NULL;
+  context.modified_path = NULL;
+  context.iterator = 0;
+  context.ignore = 0;
+  context.iterator_error = BROTLI_FALSE;
+  context.buffer = NULL;
+  context.current_input_path = NULL;
+  context.current_output_path = NULL;
+  context.fin = NULL;
+  context.fout = NULL;
+
+  command = ParseParams(&context);
+
+  if (command == COMMAND_COMPRESS || command == COMMAND_DECOMPRESS ||
+      command == COMMAND_TEST_INTEGRITY) {
+    if (!ReadDictionary(&context, command)) is_ok = BROTLI_FALSE;
+    if (is_ok) {
+      size_t modified_path_len =
+          context.longest_path_len + strlen(context.suffix) + 1;
+      context.modified_path = (char*)malloc(modified_path_len);
+      context.buffer = (uint8_t*)malloc(kFileBufferSize * 2);
+      if (!context.modified_path || !context.buffer) {
+        fprintf(stderr, "out of memory\n");
+        is_ok = BROTLI_FALSE;
+      } else {
+        context.input = context.buffer;
+        context.output = context.buffer + kFileBufferSize;
+      }
+    }
+  }
+
+  if (!is_ok) command = COMMAND_NOOP;
+
+  switch (command) {
+    case COMMAND_NOOP:
+      break;
+
+    case COMMAND_VERSION:
+      PrintVersion();
+      break;
+
+    case COMMAND_COMPRESS:
+      is_ok = CompressFiles(&context);
+      break;
+
+    case COMMAND_DECOMPRESS:
+    case COMMAND_TEST_INTEGRITY:
+      is_ok = DecompressFiles(&context);
+      break;
+
+    case COMMAND_HELP:
+    case COMMAND_INVALID:
+    default:
+      is_ok = (command == COMMAND_HELP);
+      PrintHelp(FileName(argv[0]), is_ok);
+      break;
+  }
+
+  if (context.iterator_error) is_ok = BROTLI_FALSE;
+
+  BrotliEncoderDestroyPreparedDictionary(context.prepared_dictionary);
+  free(context.dictionary);
+  free(context.modified_path);
+  free(context.buffer);
+
+  if (!is_ok) exit(1);
+  return 0;
+}
diff --git a/src/native/external/brotli/c/tools/brotli.md b/src/native/external/brotli/c/tools/brotli.md
new file mode 100644
index 00000000000000..cb6d6f3813c1f1
--- /dev/null
+++ b/src/native/external/brotli/c/tools/brotli.md
@@ -0,0 +1,108 @@
+# NAME
+
+brotli(1) -- brotli, unbrotli - compress or decompress files
+
+# SYNOPSIS
+
+`brotli` [*OPTION|FILE*]...
+
+`unbrotli` is equivalent to `brotli --decompress`
+
+# DESCRIPTION
+
+`brotli` is a generic-purpose lossless compression algorithm that compresses
+data using a combination of a modern variant of the **LZ77** algorithm, Huffman
+coding and 2-nd order context modeling, with a compression ratio comparable to
+the best currently available general-purpose compression methods. It is similar
+in speed with deflate but offers more dense compression.
+
+`brotli` command line syntax similar to `gzip (1)` and `zstd (1)`.
+Unlike `gzip (1)`, source files are preserved by default. It is possible to
+remove them after processing by using the `--rm` _option_.
+
+Arguments that look like "`--name`" or "`--name=value`" are _options_. Every
+_option_ has a short form "`-x`" or "`-x value`". Multiple short form _options_
+could be coalesced:
+
+* "`--decompress --stdout --suffix=.b`" works the same as
+* "`-d -s -S .b`" and
+* "`-dsS .b`"
+
+`brotli` has 3 operation modes:
+
+* default mode is compression;
+* `--decompress` option activates decompression mode;
+* `--test` option switches to integrity test mode; this option is equivalent to
+  "`--decompress --stdout`" except that the decompressed data is discarded
+  instead of being written to standard output.
+
+Every non-option argument is a _file_ entry. If no _files_ are given or _file_
+is "`-`", `brotli` reads from standard input. All arguments after "`--`" are
+_file_ entries.
+
+Unless `--stdout` or `--output` is specified, _files_ are written to a new file
+whose name is derived from the source _file_ name:
+
+* when compressing, a suffix is appended to the source filename to
+  get the target filename
+* when decompressing, a suffix is removed from the source filename to
+  get the target filename
+
+Default suffix is `.br`, but it could be specified with `--suffix` option.
+
+Conflicting or duplicate _options_ are not allowed.
+
+# OPTIONS
+
+* `-#`:
+    compression level (0-9); bigger values cause denser, but slower compression
+* `-c`, `--stdout`:
+    write on standard output
+* `-d`, `--decompress`:
+    decompress mode
+* `-f`, `--force`:
+    force output file overwrite
+* `-h`, `--help`:
+    display this help and exit
+* `-j`, `--rm`:
+    remove source file(s); `gzip (1)`-like behaviour
+* `-k`, `--keep`:
+    keep source file(s); `zstd (1)`-like behaviour
+* `-n`, `--no-copy-stat`:
+    do not copy source file(s) attributes
+* `-o FILE`, `--output=FILE`
+    output file; valid only if there is a single input entry
+* `-q NUM`, `--quality=NUM`:
+    compression level (0-11); bigger values cause denser, but slower compression
+* `-t`, `--test`:
+    test file integrity mode
+* `-v`, `--verbose`:
+    increase output verbosity
+* `-w NUM`, `--lgwin=NUM`:
+    set LZ77 window size (0, 10-24) (default: 24); window size is
+    `(pow(2, NUM) - 16)`; 0 lets compressor decide over the optimal value;
+    bigger windows size improve density; decoder might require up to window size
+    memory to operate
+* `-D FILE`, `--dictionary=FILE`:
+    use FILE as raw (LZ77) dictionary; same dictionary MUST be used both for
+    compression and decompression
+* `-S SUF`, `--suffix=SUF`:
+    output file suffix (default: `.br`)
+* `-V`, `--version`:
+    display version and exit
+* `-Z`, `--best`:
+    use best compression level (default); same as "`-q 11`"
+
+# SEE ALSO
+
+`brotli` file format is defined in
+[RFC 7932](https://www.ietf.org/rfc/rfc7932.txt).
+
+`brotli` is open-sourced under the
+[MIT License](https://opensource.org/licenses/MIT).
+
+Mailing list: https://groups.google.com/forum/#!forum/brotli
+
+# BUGS
+
+Report bugs at: https://github.com/google/brotli/issues
diff --git a/src/native/external/brotli/compiler_config_setting.bzl b/src/native/external/brotli/compiler_config_setting.bzl
new file mode 100644
index 00000000000000..b7bb7b9d1f5f7b
--- /dev/null
+++ b/src/native/external/brotli/compiler_config_setting.bzl
@@ -0,0 +1,40 @@
+# Copyright 2018 Google Inc. All Rights Reserved.
+#
+# Distributed under MIT license.
+#  See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+
+"""Creates config_setting that allows selecting based on 'compiler' value."""
+
+def create_msvc_config():
+  # The "do_not_use_tools_cpp_compiler_present" attribute exists to
+  # distinguish between older versions of Bazel that do not support
+  # "@bazel_tools//tools/cpp:compiler" flag_value, and newer ones that do.
+  # In the future, the only way to select on the compiler will be through
+  # flag_values{"@bazel_tools//tools/cpp:compiler"} and the else branch can
+  # be removed.
+  if hasattr(cc_common, "do_not_use_tools_cpp_compiler_present"):
+    native.config_setting(
+      name = "clang-cl",
+      flag_values = {
+          "@bazel_tools//tools/cpp:compiler": "clang-cl",
+      },
+      visibility = ["//visibility:public"],
+    )
+    native.config_setting(
+      name = "msvc",
+      flag_values = {
+          "@bazel_tools//tools/cpp:compiler": "msvc-cl",
+      },
+      visibility = ["//visibility:public"],
+    )
+  else:
+    native.config_setting(
+      name = "clang-cl",
+      values = {"compiler": "clang-cl"},
+      visibility = ["//visibility:public"],
+    )
+    native.config_setting(
+      name = "msvc",
+      values = {"compiler": "msvc-cl"},
+      visibility = ["//visibility:public"],
+    )
diff --git a/src/native/external/brotli/scripts/libbrotlicommon.pc.in b/src/native/external/brotli/scripts/libbrotlicommon.pc.in
new file mode 100644
index 00000000000000..2a8cf7a35e8de3
--- /dev/null
+++ b/src/native/external/brotli/scripts/libbrotlicommon.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libbrotlicommon
+URL: https://github.com/google/brotli
+Description: Brotli common dictionary library
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lbrotlicommon
+Cflags: -I${includedir}
diff --git a/src/native/external/brotli/scripts/libbrotlidec.pc.in b/src/native/external/brotli/scripts/libbrotlidec.pc.in
new file mode 100644
index 00000000000000..ecb8f46ab1e80d
--- /dev/null
+++ b/src/native/external/brotli/scripts/libbrotlidec.pc.in
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libbrotlidec
+URL: https://github.com/google/brotli
+Description: Brotli decoder library
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lbrotlidec
+Requires.private: libbrotlicommon >= 1.1.0
+Cflags: -I${includedir}
diff --git a/src/native/external/brotli/scripts/libbrotlienc.pc.in b/src/native/external/brotli/scripts/libbrotlienc.pc.in
new file mode 100644
index 00000000000000..5bedb2f0f15009
--- /dev/null
+++ b/src/native/external/brotli/scripts/libbrotlienc.pc.in
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libbrotlienc
+URL: https://github.com/google/brotli
+Description: Brotli encoder library
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lbrotlienc
+Requires.private: libbrotlicommon >= 1.1.0
+Cflags: -I${includedir}
diff --git a/src/native/external/brotli/setup.cfg b/src/native/external/brotli/setup.cfg
new file mode 100644
index 00000000000000..16da438a72a411
--- /dev/null
+++ b/src/native/external/brotli/setup.cfg
@@ -0,0 +1,5 @@
+[build]
+build_base=bin
+
+[yapf]
+based_on_style=google
diff --git a/src/native/external/brotli/setup.py b/src/native/external/brotli/setup.py
new file mode 100644
index 00000000000000..2cb89c396e1358
--- /dev/null
+++ b/src/native/external/brotli/setup.py
@@ -0,0 +1,292 @@
+# Copyright 2015 The Brotli Authors. All rights reserved.
+#
+# Distributed under MIT license.
+# See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+
+import os
+import platform
+import re
+import unittest
+
+try:
+    from setuptools import Extension
+    from setuptools import setup
+except:
+    from distutils.core import Extension
+    from distutils.core import setup
+from distutils.command.build_ext import build_ext
+from distutils import errors
+from distutils import dep_util
+from distutils import log
+
+
+CURR_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
+
+
+def read_define(path, macro):
+  """ Return macro value from the given file. """
+  with open(path, 'r') as f:
+    for line in f:
+      m = re.match(rf'#define\s{macro}\s+(.+)', line)
+      if m:
+        return m.group(1)
+  return ''
+
+
+def get_version():
+  """ Return library version string from 'common/version.h' file. """
+  version_file_path = os.path.join(CURR_DIR, 'c', 'common', 'version.h')
+  major = read_define(version_file_path, 'BROTLI_VERSION_MAJOR')
+  minor = read_define(version_file_path, 'BROTLI_VERSION_MINOR')
+  patch = read_define(version_file_path, 'BROTLI_VERSION_PATCH')
+  if not major or not minor or not patch:
+    return ''
+  return f'{major}.{minor}.{patch}'
+
+
+def get_test_suite():
+  test_loader = unittest.TestLoader()
+  test_suite = test_loader.discover('python', pattern='*_test.py')
+  return test_suite
+
+
+class BuildExt(build_ext):
+
+  def get_source_files(self):
+    filenames = build_ext.get_source_files(self)
+    for ext in self.extensions:
+      filenames.extend(ext.depends)
+    return filenames
+
+  def build_extension(self, ext):
+    if ext.sources is None or not isinstance(ext.sources, (list, tuple)):
+      raise errors.DistutilsSetupError(
+        "in 'ext_modules' option (extension '%s'), "
+        "'sources' must be present and must be "
+        "a list of source filenames" % ext.name)
+
+    ext_path = self.get_ext_fullpath(ext.name)
+    depends = ext.sources + ext.depends
+    if not (self.force or dep_util.newer_group(depends, ext_path, 'newer')):
+      log.debug("skipping '%s' extension (up-to-date)", ext.name)
+      return
+    else:
+      log.info("building '%s' extension", ext.name)
+
+    c_sources = []
+    for source in ext.sources:
+      if source.endswith('.c'):
+        c_sources.append(source)
+    extra_args = ext.extra_compile_args or []
+
+    objects = []
+
+    macros = ext.define_macros[:]
+    if platform.system() == 'Darwin':
+      macros.append(('OS_MACOSX', '1'))
+    elif self.compiler.compiler_type == 'mingw32':
+      # On Windows Python 2.7, pyconfig.h defines "hypot" as "_hypot",
+      # This clashes with GCC's cmath, and causes compilation errors when
+      # building under MinGW: http://bugs.python.org/issue11566
+      macros.append(('_hypot', 'hypot'))
+    for undef in ext.undef_macros:
+      macros.append((undef,))
+
+    objs = self.compiler.compile(
+        c_sources,
+        output_dir=self.build_temp,
+        macros=macros,
+        include_dirs=ext.include_dirs,
+        debug=self.debug,
+        extra_postargs=extra_args,
+        depends=ext.depends)
+    objects.extend(objs)
+
+    self._built_objects = objects[:]
+    if ext.extra_objects:
+      objects.extend(ext.extra_objects)
+    extra_args = ext.extra_link_args or []
+    # when using GCC on Windows, we statically link libgcc and libstdc++,
+    # so that we don't need to package extra DLLs
+    if self.compiler.compiler_type == 'mingw32':
+        extra_args.extend(['-static-libgcc', '-static-libstdc++'])
+
+    ext_path = self.get_ext_fullpath(ext.name)
+    # Detect target language, if not provided
+    language = ext.language or self.compiler.detect_language(c_sources)
+
+    self.compiler.link_shared_object(
+        objects,
+        ext_path,
+        libraries=self.get_libraries(ext),
+        library_dirs=ext.library_dirs,
+        runtime_library_dirs=ext.runtime_library_dirs,
+        extra_postargs=extra_args,
+        export_symbols=self.get_export_symbols(ext),
+        debug=self.debug,
+        build_temp=self.build_temp,
+        target_lang=language)
+
+
+NAME = 'Brotli'
+
+VERSION = get_version()
+
+URL = 'https://github.com/google/brotli'
+
+DESCRIPTION = 'Python bindings for the Brotli compression library'
+
+AUTHOR = 'The Brotli Authors'
+
+LICENSE = 'MIT'
+
+PLATFORMS = ['Posix', 'MacOS X', 'Windows']
+
+CLASSIFIERS = [
+    'Development Status :: 4 - Beta',
+    'Environment :: Console',
+    'Intended Audience :: Developers',
+    'License :: OSI Approved :: MIT License',
+    'Operating System :: MacOS :: MacOS X',
+    'Operating System :: Microsoft :: Windows',
+    'Operating System :: POSIX :: Linux',
+    'Programming Language :: C',
+    'Programming Language :: C++',
+    'Programming Language :: Python',
+    'Programming Language :: Python :: 2',
+    'Programming Language :: Python :: 2.7',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.3',
+    'Programming Language :: Python :: 3.4',
+    'Programming Language :: Python :: 3.5',
+    'Programming Language :: Unix Shell',
+    'Topic :: Software Development :: Libraries',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+    'Topic :: System :: Archiving',
+    'Topic :: System :: Archiving :: Compression',
+    'Topic :: Text Processing :: Fonts',
+    'Topic :: Utilities',
+]
+
+PACKAGE_DIR = {'': 'python'}
+
+PY_MODULES = ['brotli']
+
+EXT_MODULES = [
+    Extension(
+        '_brotli',
+        sources=[
+            'python/_brotli.c',
+            'c/common/constants.c',
+            'c/common/context.c',
+            'c/common/dictionary.c',
+            'c/common/platform.c',
+            'c/common/shared_dictionary.c',
+            'c/common/transform.c',
+            'c/dec/bit_reader.c',
+            'c/dec/decode.c',
+            'c/dec/huffman.c',
+            'c/dec/state.c',
+            'c/enc/backward_references.c',
+            'c/enc/backward_references_hq.c',
+            'c/enc/bit_cost.c',
+            'c/enc/block_splitter.c',
+            'c/enc/brotli_bit_stream.c',
+            'c/enc/cluster.c',
+            'c/enc/command.c',
+            'c/enc/compound_dictionary.c',
+            'c/enc/compress_fragment.c',
+            'c/enc/compress_fragment_two_pass.c',
+            'c/enc/dictionary_hash.c',
+            'c/enc/encode.c',
+            'c/enc/encoder_dict.c',
+            'c/enc/entropy_encode.c',
+            'c/enc/fast_log.c',
+            'c/enc/histogram.c',
+            'c/enc/literal_cost.c',
+            'c/enc/memory.c',
+            'c/enc/metablock.c',
+            'c/enc/static_dict.c',
+            'c/enc/utf8_util.c',
+        ],
+        depends=[
+            'c/common/constants.h',
+            'c/common/context.h',
+            'c/common/dictionary.h',
+            'c/common/platform.h',
+            'c/common/shared_dictionary_internal.h',
+            'c/common/transform.h',
+            'c/common/version.h',
+            'c/dec/bit_reader.h',
+            'c/dec/huffman.h',
+            'c/dec/prefix.h',
+            'c/dec/state.h',
+            'c/enc/backward_references.h',
+            'c/enc/backward_references_hq.h',
+            'c/enc/backward_references_inc.h',
+            'c/enc/bit_cost.h',
+            'c/enc/bit_cost_inc.h',
+            'c/enc/block_encoder_inc.h',
+            'c/enc/block_splitter.h',
+            'c/enc/block_splitter_inc.h',
+            'c/enc/brotli_bit_stream.h',
+            'c/enc/cluster.h',
+            'c/enc/cluster_inc.h',
+            'c/enc/command.h',
+            'c/enc/compound_dictionary.h',
+            'c/enc/compress_fragment.h',
+            'c/enc/compress_fragment_two_pass.h',
+            'c/enc/dictionary_hash.h',
+            'c/enc/encoder_dict.h',
+            'c/enc/entropy_encode.h',
+            'c/enc/entropy_encode_static.h',
+            'c/enc/fast_log.h',
+            'c/enc/find_match_length.h',
+            'c/enc/hash.h',
+            'c/enc/hash_composite_inc.h',
+            'c/enc/hash_forgetful_chain_inc.h',
+            'c/enc/hash_longest_match64_inc.h',
+            'c/enc/hash_longest_match_inc.h',
+            'c/enc/hash_longest_match_quickly_inc.h',
+            'c/enc/hash_rolling_inc.h',
+            'c/enc/hash_to_binary_tree_inc.h',
+            'c/enc/histogram.h',
+            'c/enc/histogram_inc.h',
+            'c/enc/literal_cost.h',
+            'c/enc/memory.h',
+            'c/enc/metablock.h',
+            'c/enc/metablock_inc.h',
+            'c/enc/params.h',
+            'c/enc/prefix.h',
+            'c/enc/quality.h',
+            'c/enc/ringbuffer.h',
+            'c/enc/static_dict.h',
+            'c/enc/static_dict_lut.h',
+            'c/enc/utf8_util.h',
+            'c/enc/write_bits.h',
+        ],
+        include_dirs=[
+            'c/include',
+        ]),
+]
+
+TEST_SUITE = 'setup.get_test_suite'
+
+CMD_CLASS = {
+    'build_ext': BuildExt,
+}
+
+setup(
+    name=NAME,
+    description=DESCRIPTION,
+    version=VERSION,
+    url=URL,
+    author=AUTHOR,
+    license=LICENSE,
+    platforms=PLATFORMS,
+    classifiers=CLASSIFIERS,
+    package_dir=PACKAGE_DIR,
+    py_modules=PY_MODULES,
+    ext_modules=EXT_MODULES,
+    test_suite=TEST_SUITE,
+    cmdclass=CMD_CLASS)
diff --git a/src/native/libs/System.IO.Compression.Native/CMakeLists.txt b/src/native/libs/System.IO.Compression.Native/CMakeLists.txt
index ac152c16f12dbe..81b9f69b8d88b8 100644
--- a/src/native/libs/System.IO.Compression.Native/CMakeLists.txt
+++ b/src/native/libs/System.IO.Compression.Native/CMakeLists.txt
@@ -6,6 +6,14 @@ if (NOT CLR_CMAKE_USE_SYSTEM_ZLIB)
     include(${CLR_SRC_NATIVE_DIR}/external/zlib-ng.cmake)
 endif()
 
+if (CLR_CMAKE_USE_SYSTEM_BROTLI)
+    if (CLR_CMAKE_HOST_FREEBSD)
+        set(CMAKE_REQUIRED_INCLUDES ${CROSS_ROOTFS}/usr/local/include)
+    endif()
+else()
+    include(${CLR_SRC_NATIVE_DIR}/external/brotli.cmake)
+endif()
+
 configure_file(
     ${CMAKE_CURRENT_SOURCE_DIR}/../Common/pal_config.h.in
     ${CMAKE_CURRENT_BINARY_DIR}/pal_config.h)
@@ -15,21 +23,6 @@ set(NATIVECOMPRESSION_SOURCES
 )
 
 if (NOT CLR_CMAKE_TARGET_BROWSER AND NOT CLR_CMAKE_TARGET_WASI)
-
-    if (CLR_CMAKE_USE_SYSTEM_BROTLI)
-        add_definitions(-DFEATURE_USE_SYSTEM_BROTLI)
-        if (CLR_CMAKE_HOST_FREEBSD)
-            set(CMAKE_REQUIRED_INCLUDES ${CROSS_ROOTFS}/usr/local/include)
-        endif()
-    else ()
-        include(${CLR_SRC_NATIVE_DIR}/external/brotli.cmake)
-
-        set (NATIVECOMPRESSION_SOURCES
-            ${NATIVECOMPRESSION_SOURCES}
-            ${BROTLI_SOURCES}
-        )
-    endif ()
-
     set (NATIVECOMPRESSION_SOURCES
         ${NATIVECOMPRESSION_SOURCES}
         entrypoints.c
@@ -59,6 +52,9 @@ if (CLR_CMAKE_TARGET_UNIX OR CLR_CMAKE_TARGET_BROWSER OR CLR_CMAKE_TARGET_WASI)
             ${NATIVE_LIBS_EXTRA}
         )
 
+        target_include_directories(System.IO.Compression.Native PRIVATE ${BROTLI_INCLUDE_DIRS})
+        target_link_libraries(System.IO.Compression.Native PRIVATE ${BROTLI_LIBRARIES})
+
         if (NOT CLR_CMAKE_TARGET_MACCATALYST AND NOT CLR_CMAKE_TARGET_IOS AND NOT CLR_CMAKE_TARGET_TVOS AND NOT CLR_CMAKE_TARGET_ANDROID AND NOT CLR_CMAKE_USE_SYSTEM_BROTLI)
             set(DEF_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/System.IO.Compression.Native_unixexports.src)
             set(EXPORTS_FILE ${CMAKE_CURRENT_BINARY_DIR}/System.IO.Compression.Native.exports)
@@ -94,11 +90,30 @@ if (CLR_CMAKE_TARGET_UNIX OR CLR_CMAKE_TARGET_BROWSER OR CLR_CMAKE_TARGET_WASI)
     endif()
 
     set_target_properties(System.IO.Compression.Native-Static PROPERTIES OUTPUT_NAME System.IO.Compression.Native CLEAN_DIRECT_OUTPUT 1)
+    target_link_libraries(System.IO.Compression.Native-Static
+        PUBLIC
+        ${NATIVE_LIBS_EXTRA}
+    )
+
+    target_include_directories(System.IO.Compression.Native-Static PUBLIC ${BROTLI_INCLUDE_DIRS})
+    target_link_libraries(System.IO.Compression.Native-Static PUBLIC ${BROTLI_LIBRARIES})
+
+    foreach(BROTLI_LIB ${BROTLI_LIBRARIES})
+        # Brotli's build scripts can add some system dependencies like libm
+        # to BROTLI_LIBRARIES. Only install the libraries that are actually
+        # defined as CMake targets.
+        if (TARGET "${BROTLI_LIB}")
+            install (TARGETS ${BROTLI_LIB} DESTINATION ${STATIC_LIB_DESTINATION} COMPONENT libs)
+        endif()
+    endforeach(BROTLI_LIB ${BROTLI_LIBRARIES})
 
     if (NOT CLR_CMAKE_USE_SYSTEM_ZLIB)
         install (TARGETS zlib DESTINATION ${STATIC_LIB_DESTINATION} COMPONENT libs)
     endif()
 else ()
+    set(NATIVE_LIBS_EXTRA)
+    append_extra_compression_libs(NATIVE_LIBS_EXTRA)
+
     if (GEN_SHARED_LIB)
         include (GenerateExportHeader)
     endif ()
@@ -115,6 +130,9 @@ else ()
         if (NOT CLR_CMAKE_USE_SYSTEM_ZLIB)
             target_link_libraries(System.IO.Compression.Native PRIVATE zlib)
         endif()
+
+        target_include_directories(System.IO.Compression.Native PUBLIC ${BROTLI_INCLUDE_DIRS})
+        target_link_libraries(System.IO.Compression.Native PUBLIC ${BROTLI_LIBRARIES})
     endif ()
 
     if (NOT GEN_SHARED_LIB AND NOT CLR_CMAKE_TARGET_MACCATALYST AND NOT CLR_CMAKE_TARGET_IOS AND NOT CLR_CMAKE_TARGET_TVOS AND NOT CLR_CMAKE_TARGET_ANDROID AND NOT CLR_CMAKE_TARGET_BROWSER AND NOT CLR_CMAKE_TARGET_WASI)
@@ -130,6 +148,9 @@ else ()
         target_link_libraries(System.IO.Compression.Native-Static PRIVATE zlibstatic)
     endif()
 
+    target_include_directories(System.IO.Compression.Native-Static PUBLIC ${BROTLI_INCLUDE_DIRS})
+    target_link_libraries(System.IO.Compression.Native-Static PUBLIC ${BROTLI_LIBRARIES})
+
     if(STATIC_LIBS_ONLY)
         add_library(System.IO.Compression.Native.Aot
             STATIC
@@ -140,6 +161,9 @@ else ()
             target_link_libraries(System.IO.Compression.Native.Aot PRIVATE zlibstatic)
         endif()
 
+        target_include_directories(System.IO.Compression.Native.Aot PUBLIC ${BROTLI_INCLUDE_DIRS})
+        target_link_libraries(System.IO.Compression.Native.Aot PUBLIC ${BROTLI_LIBRARIES})
+
         set_target_properties(System.IO.Compression.Native.Aot PROPERTIES CLR_CONTROL_FLOW_GUARD OFF)
         set_target_properties(System.IO.Compression.Native.Aot PROPERTIES INTERPROCEDURAL_OPTIMIZATION OFF)
 
@@ -152,6 +176,9 @@ else ()
             target_link_libraries(System.IO.Compression.Native.Aot.GuardCF PRIVATE zlibstatic)
         endif()
 
+        target_include_directories(System.IO.Compression.Native.Aot.GuardCF PUBLIC ${BROTLI_INCLUDE_DIRS})
+        target_link_libraries(System.IO.Compression.Native.Aot.GuardCF PUBLIC ${BROTLI_LIBRARIES})
+
         set_target_properties(System.IO.Compression.Native.Aot.GuardCF PROPERTIES INTERPROCEDURAL_OPTIMIZATION OFF)
     endif()
 
@@ -170,6 +197,14 @@ else ()
     if(STATIC_LIBS_ONLY)
         install_static_library(System.IO.Compression.Native.Aot aotsdk nativeaot)
         install_static_library(System.IO.Compression.Native.Aot.GuardCF aotsdk nativeaot)
+        foreach(BROTLI_LIB ${BROTLI_LIBRARIES})
+            # Brotli's build scripts can add some system dependencies like libm
+            # to BROTLI_LIBRARIES. Only install the libraries that are actually
+            # defined as CMake targets.
+            if (TARGET "${BROTLI_LIB}")
+                install_static_library(${BROTLI_LIB} aotsdk nativeaot)
+            endif()
+        endforeach(BROTLI_LIB ${BROTLI_LIBRARIES})
         if (NOT CLR_CMAKE_USE_SYSTEM_ZLIB)
             install_static_library(zlib aotsdk nativeaot)
         endif()
diff --git a/src/native/libs/System.IO.Compression.Native/extra_libs.cmake b/src/native/libs/System.IO.Compression.Native/extra_libs.cmake
index 03b40533e2109d..f10684f561bf70 100644
--- a/src/native/libs/System.IO.Compression.Native/extra_libs.cmake
+++ b/src/native/libs/System.IO.Compression.Native/extra_libs.cmake
@@ -19,11 +19,4 @@ macro(append_extra_compression_libs NativeLibsExtra)
     list(APPEND ZLIB_LIBRARIES $<IF:$<BOOL:${CLR_CMAKE_USE_SYSTEM_ZLIB}>,z,zlib>)
   endif ()
   list(APPEND ${NativeLibsExtra} ${ZLIB_LIBRARIES})
-
-  if (CLR_CMAKE_USE_SYSTEM_BROTLI)
-    find_library(BROTLIDEC brotlidec REQUIRED)
-    find_library(BROTLIENC brotlienc REQUIRED)
-
-    list(APPEND ${NativeLibsExtra} ${BROTLIDEC} ${BROTLIENC})
-  endif ()
 endmacro()
diff --git a/src/tasks/AppleAppBuilder/Templates/CMakeLists-librarymode.txt.template b/src/tasks/AppleAppBuilder/Templates/CMakeLists-librarymode.txt.template
index d47279b942fb48..43779a5eab88fe 100644
--- a/src/tasks/AppleAppBuilder/Templates/CMakeLists-librarymode.txt.template
+++ b/src/tasks/AppleAppBuilder/Templates/CMakeLists-librarymode.txt.template
@@ -76,7 +76,7 @@ target_link_libraries(
 )
 
 set_target_properties(
-    %ProjectName% 
+    %ProjectName%
     PROPERTIES LINK_FLAGS
     %EXTRA_LINKER_ARGS%
 )
diff --git a/src/tasks/AppleAppBuilder/Templates/CMakeLists.txt.template b/src/tasks/AppleAppBuilder/Templates/CMakeLists.txt.template
index 141a8f3edad0ad..d988551bedf1bb 100644
--- a/src/tasks/AppleAppBuilder/Templates/CMakeLists.txt.template
+++ b/src/tasks/AppleAppBuilder/Templates/CMakeLists.txt.template
@@ -85,7 +85,7 @@ target_link_libraries(
 )
 
 set_target_properties(
-    %ProjectName% 
+    %ProjectName%
     PROPERTIES LINK_FLAGS
     %EXTRA_LINKER_ARGS%
 )
diff --git a/src/tasks/AppleAppBuilder/Xcode.cs b/src/tasks/AppleAppBuilder/Xcode.cs
index aed4bf7dfaeba3..ce13c9bf008d14 100644
--- a/src/tasks/AppleAppBuilder/Xcode.cs
+++ b/src/tasks/AppleAppBuilder/Xcode.cs
@@ -407,7 +407,10 @@ public string GenerateCMake(
             }
 
             string[] dylibs = Directory.GetFiles(workspace, "*.dylib");
-            foreach (string lib in Directory.GetFiles(workspace, "*.a"))
+
+            // Sort the static libraries to link so the brotli libs are added to the list last (after the compression native libs)
+            List<string> staticLibsToLink = Directory.GetFiles(workspace, "*.a").OrderBy(libName => libName.Contains("brotli") ? 1 : 0).ToList();
+            foreach (string lib in staticLibsToLink)
             {
                 // all component libs already added to linker.
                 if (allComponentLibs.Any(lib.Contains))
diff --git a/src/tasks/LibraryBuilder/LibraryBuilder.cs b/src/tasks/LibraryBuilder/LibraryBuilder.cs
index fa181eb9c40c87..1ad0a3cbae7f37 100644
--- a/src/tasks/LibraryBuilder/LibraryBuilder.cs
+++ b/src/tasks/LibraryBuilder/LibraryBuilder.cs
@@ -197,6 +197,9 @@ private void GatherSourcesAndLibs(List<string> sources, List<string> libs, List<
             }
         }
 
+        // Add dependencies of any runtime libraries explicitly after the runtime libraries
+        // to ensure that dependencies show up on the linker command line after their dependents.
+        List<string> bundledStaticLibs = [];
         foreach (ITaskItem lib in RuntimeLibraries)
         {
             string ext = Path.GetExtension(lib.ItemSpec);
@@ -205,12 +208,18 @@ private void GatherSourcesAndLibs(List<string> sources, List<string> libs, List<
             {
                 libs.Add(lib.ItemSpec);
             }
+            else if (lib.ItemSpec.Contains("brotli"))
+            {
+                bundledStaticLibs.Add(lib.ItemSpec);
+            }
             else
             {
                 sources.Add(lib.ItemSpec);
             }
         }
 
+        sources.AddRange(bundledStaticLibs);
+
         foreach (ITaskItem item in ExtraLinkerArguments)
         {
             linkerArgs.Add(item.ItemSpec);