Add files using upload-large-folder tool

.gitattributes

@@ -1465,3 +1465,385 @@ msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x64/ucrtd.osmode.lib filter
 msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x64/ucrtd.osmode_permissive.lib filter=lfs diff=lfs merge=lfs -text
 msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x86/libucrt.lib filter=lfs diff=lfs merge=lfs -text
 msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x86/libucrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x86/ucrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x86/ucrt.osmode.lib filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x86/ucrt.osmode_permissive.lib filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x86/ucrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x86/ucrtd.osmode.lib filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/Lib/10.0.26100.0/ucrt/x86/ucrtd.osmode_permissive.lib filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/accevent.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/appxpackaging.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/certmgr.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/cppwinrt.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/d3dcompiler_47.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/dxc.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/dxcapsviewer.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/dxcompiler.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/dxil.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/fxc.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/gamesaveutil.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/inspect.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/makeappx.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/makepri.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/mc.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/mdmerge.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/mfdetours.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/mftrace.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/Microsoft.Diagnostics.Tracing.EventSource.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/Microsoft.Msix.Utils.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/midl.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/midlc.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/midlrt.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/midlrtmd.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/mrmsupport.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/msisip.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/mt.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/rcdll.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/regwinmd.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/ServicingCommon.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/tedutil.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/topoedit.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/winmdidl.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/wstraceutil.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/wsutil.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/wsutilhelper.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/AccChecker/acccheckui.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/AccChecker/IE.Interop.MSHTML.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/AccChecker/Microsoft.Diagnostics.Tracing.EventSource.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/ucrt/ucrtbased.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/UIAVerify/Interop.UIAutomationClient.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/UIAVerify/Microsoft.UIAutomationClient.Interop.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/UIAVerify/UIAComWrapper.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/UIAVerify/VisualUIAVerifyNative.exe filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/UIAVerify/VisualUIAVerifyNative.resources.dll filter=lfs diff=lfs merge=lfs -text
+msvc/Windows[[:space:]]Kits/10/bin/10.0.26100.0/x64/UIAVerify/WUIATestLibrary.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/aligned_new.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.asan_dbg_dynamic-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.asan_dbg_nonewdelete_dynamic-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.asan_dynamic-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.asan_dynamic_runtime_thunk-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.asan_nonewdelete_dynamic-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.asan_static_runtime_thunk-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.builtins-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.fuzzer_MD-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.fuzzer_MDd-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.fuzzer_MT-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.fuzzer_MTd-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.fuzzer_no_main_MD-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.fuzzer_no_main_MDd-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.fuzzer_no_main_MT-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.fuzzer_no_main_MTd-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.profile-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.stats-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.ubsan_standalone-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/clang_rt.ubsan_standalone_cxx-x86_64.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/comsupp.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/comsuppd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/comsuppw.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/comsuppwd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/concrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/concrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/delayimp.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/exe_initialize_mta.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/legacy_stdio_definitions.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcmt.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcmt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcmtd.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcmtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrt.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrt1.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrt1.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrtd.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrtd0.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrtd0.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrtd1.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libconcrtd1.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmt.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmt1.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmt1.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmtd.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmtd0.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmtd0.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmtd1.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libcpmtd1.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libomp.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libompd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libsancov.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libsancovd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libvcasan.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libvcasand.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libvcruntime.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libvcruntime.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libvcruntimed.amd64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/libvcruntimed.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/msvcmrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/msvcmrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/msvcmrtd_netcore.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/msvcmrt_netcore.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/msvcprt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/msvcprtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/msvcrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/msvcrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/oldnames.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/ptrustm.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/ptrustmd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/sancov.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/sancovd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/vcasan.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/vcasand.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/vccorlib.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/vccorlibd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/vcruntime.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x64/vcruntimed.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/aligned_new.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.asan_dbg_dynamic-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.asan_dbg_nonewdelete_dynamic-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.asan_dynamic-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.asan_dynamic_runtime_thunk-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.asan_nonewdelete_dynamic-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.asan_static_runtime_thunk-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.builtins-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.fuzzer_MD-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.fuzzer_MDd-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.fuzzer_MT-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.fuzzer_MTd-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.fuzzer_no_main_MD-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.fuzzer_no_main_MDd-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.fuzzer_no_main_MT-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.fuzzer_no_main_MTd-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.profile-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.stats-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.ubsan_standalone-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/clang_rt.ubsan_standalone_cxx-i386.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/comsupp.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/comsuppd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/comsuppw.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/comsuppwd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/concrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/concrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/delayimp.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/exe_initialize_mta.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/legacy_stdio_definitions.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcmt.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcmt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcmtd.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcmtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrt.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrt1.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrt1.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrtd.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrtd0.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrtd0.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrtd1.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libconcrtd1.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmt.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmt1.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmt1.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmtd.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmtd0.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmtd0.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmtd1.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libcpmtd1.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libomp.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libompd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libsancov.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libsancovd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libvcasan.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libvcasand.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libvcruntime.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libvcruntime.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libvcruntimed.i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/libvcruntimed.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/msvcmrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/msvcmrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/msvcmrtd_netcore.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/msvcmrt_netcore.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/msvcprt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/msvcprtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/msvcrt.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/msvcrtd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/oldnames.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/ptrustm.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/ptrustmd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/sancov.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/sancovd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/vcasan.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/vcasand.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/vccorlib.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/vccorlibd.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/vcruntime.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/lib/x86/vcruntimed.lib filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/atlprov.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/bscmake.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/c1.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/c1xx.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/c2.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/c2dd.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/cl.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/clang_rt.asan_dbg_dynamic-x86_64.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/clang_rt.asan_dbg_dynamic-x86_64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/clang_rt.asan_dynamic-x86_64.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/clang_rt.asan_dynamic-x86_64.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/concrt140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/CppBuildInsights.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/d3dcompiler_47.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/dpcmi.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/ifc.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/KernelTraceControl.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/libomp140.x86_64.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/libomp140d.x86_64.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/link.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/llvm-symbolizer.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/Microsoft.Diagnostics.Tracing.EventSource.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/Microsoft.VisualStudio.Telemetry.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/ml64.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/msdia140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/msobj140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/mspdb140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/mspdbcmf.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/mspdbcore.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/mspdbsrv.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/mspdbst.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/mspft140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/msvcdis140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/msvcp140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/msvcp140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/msvcp140_2.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/msvcp140_2d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/nmake.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/System.Memory.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/tbbmalloc.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/vcamp140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/vccorlib140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/vcmeta.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/vcomp140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/vcperf.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/vcruntime140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/vcruntime140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/atlprov.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/bscmake.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/c1.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/c1xx.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/c2.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/cl.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/clang_rt.asan_dbg_dynamic-i386.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/clang_rt.asan_dbg_dynamic-i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/clang_rt.asan_dynamic-i386.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/clang_rt.asan_dynamic-i386.pdb filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/concrt140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/d3dcompiler_47.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/dpcmi.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/ifc.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/libomp140.i386.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/libomp140d.i386.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/link.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/llvm-symbolizer.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/Microsoft.Diagnostics.Tracing.EventSource.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/Microsoft.VisualStudio.Telemetry.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/ml.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/msdia140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/msobj140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/mspdb140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/mspdbcmf.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/mspdbcore.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/mspdbsrv.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/mspdbst.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/mspft140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/msvcdis140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/msvcp140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/msvcp140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/msvcp140_2.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/msvcp140_2d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/Newtonsoft.Json.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/nmake.exe filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/System.Memory.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/tbbmalloc.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/vcamp140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/vccorlib140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/vcmeta.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/vcomp140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/vcruntime140.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/vcruntime140d.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/1033/clui.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/1033/linkui.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x86/1033/mspft140ui.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/1033/clui.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/1033/linkui.dll filter=lfs diff=lfs merge=lfs -text
+msvc/VC/Tools/MSVC/14.50.35717/bin/Hostx64/x64/1033/mspft140ui.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.17.10.4/Microsoft.Build.17.10.4.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Framework.17.10.4/Microsoft.Build.Framework.17.10.4.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Runtime.17.10.4/Microsoft.Build.Runtime.17.10.4.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Tasks.Core.17.10.4/Microsoft.Build.Tasks.Core.17.10.4.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Utilities.Core.17.10.4/Microsoft.Build.Utilities.Core.17.10.4.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.IO.Redist.6.0.0/Microsoft.IO.Redist.6.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.NET.StringTools.17.10.4/Microsoft.NET.StringTools.17.10.4.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Collections.Immutable.8.0.0/System.Collections.Immutable.8.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Configuration.ConfigurationManager.8.0.0/System.Configuration.ConfigurationManager.8.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Memory.4.5.5/System.Memory.4.5.5.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Numerics.Vectors.4.5.0/System.Numerics.Vectors.4.5.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.Metadata.8.0.0/System.Reflection.Metadata.8.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.MetadataLoadContext.8.0.0/System.Reflection.MetadataLoadContext.8.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Resources.Extensions.8.0.0/System.Resources.Extensions.8.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Security.Principal.Windows.5.0.0/System.Security.Principal.Windows.5.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Encodings.Web.8.0.0/System.Text.Encodings.Web.8.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/System.Text.Json.8.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Threading.Tasks.Dataflow.8.0.0/System.Threading.Tasks.Dataflow.8.0.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.ValueTuple.4.5.0/System.ValueTuple.4.5.0.nupkg filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Threading.Tasks.Dataflow.8.0.0/lib/net462/System.Threading.Tasks.Dataflow.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Threading.Tasks.Dataflow.8.0.0/lib/net6.0/System.Threading.Tasks.Dataflow.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Threading.Tasks.Dataflow.8.0.0/lib/net7.0/System.Threading.Tasks.Dataflow.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Threading.Tasks.Dataflow.8.0.0/lib/net8.0/System.Threading.Tasks.Dataflow.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Threading.Tasks.Dataflow.8.0.0/lib/netstandard2.0/System.Threading.Tasks.Dataflow.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Threading.Tasks.Dataflow.8.0.0/lib/netstandard2.1/System.Threading.Tasks.Dataflow.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/lib/net462/System.Text.Json.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/lib/net6.0/System.Text.Json.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/lib/net7.0/System.Text.Json.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/lib/net8.0/System.Text.Json.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/lib/netstandard2.0/System.Text.Json.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/analyzers/dotnet/roslyn4.4/cs/System.Text.Json.SourceGeneration.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/analyzers/dotnet/roslyn4.0/cs/System.Text.Json.SourceGeneration.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Text.Json.8.0.0/analyzers/dotnet/roslyn3.11/cs/System.Text.Json.SourceGeneration.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.MetadataLoadContext.8.0.0/lib/net462/System.Reflection.MetadataLoadContext.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.MetadataLoadContext.8.0.0/lib/net6.0/System.Reflection.MetadataLoadContext.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.MetadataLoadContext.8.0.0/lib/net7.0/System.Reflection.MetadataLoadContext.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.MetadataLoadContext.8.0.0/lib/net8.0/System.Reflection.MetadataLoadContext.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.MetadataLoadContext.8.0.0/lib/netstandard2.0/System.Reflection.MetadataLoadContext.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.Metadata.8.0.0/lib/net462/System.Reflection.Metadata.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.Metadata.8.0.0/lib/net6.0/System.Reflection.Metadata.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.Metadata.8.0.0/lib/net7.0/System.Reflection.Metadata.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.Metadata.8.0.0/lib/net8.0/System.Reflection.Metadata.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Reflection.Metadata.8.0.0/lib/netstandard2.0/System.Reflection.Metadata.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Numerics.Vectors.4.5.0/lib/net46/System.Numerics.Vectors.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Numerics.Vectors.4.5.0/lib/netstandard1.0/System.Numerics.Vectors.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Numerics.Vectors.4.5.0/lib/netstandard2.0/System.Numerics.Vectors.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Numerics.Vectors.4.5.0/lib/portable-net45+win8+wp8+wpa81/System.Numerics.Vectors.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Memory.4.5.5/lib/net461/System.Memory.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Memory.4.5.5/lib/netstandard1.1/System.Memory.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Memory.4.5.5/lib/netstandard2.0/System.Memory.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Configuration.ConfigurationManager.8.0.0/lib/net6.0/System.Configuration.ConfigurationManager.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Configuration.ConfigurationManager.8.0.0/lib/net7.0/System.Configuration.ConfigurationManager.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Configuration.ConfigurationManager.8.0.0/lib/net8.0/System.Configuration.ConfigurationManager.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Configuration.ConfigurationManager.8.0.0/lib/netstandard2.0/System.Configuration.ConfigurationManager.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Collections.Immutable.8.0.0/lib/net462/System.Collections.Immutable.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Collections.Immutable.8.0.0/lib/net6.0/System.Collections.Immutable.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Collections.Immutable.8.0.0/lib/net7.0/System.Collections.Immutable.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Collections.Immutable.8.0.0/lib/net8.0/System.Collections.Immutable.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/System.Collections.Immutable.8.0.0/lib/netstandard2.0/System.Collections.Immutable.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.IO.Redist.6.0.0/lib/net472/Microsoft.IO.Redist.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Utilities.Core.17.10.4/ref/net472/Microsoft.Build.Utilities.Core.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Utilities.Core.17.10.4/ref/net8.0/Microsoft.Build.Utilities.Core.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Utilities.Core.17.10.4/lib/net472/Microsoft.Build.Utilities.Core.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Utilities.Core.17.10.4/lib/net472/Microsoft.Build.Utilities.Core.pdb filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Utilities.Core.17.10.4/lib/net8.0/Microsoft.Build.Utilities.Core.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Utilities.Core.17.10.4/lib/net8.0/Microsoft.Build.Utilities.Core.pdb filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Tasks.Core.17.10.4/ref/net472/Microsoft.Build.Tasks.Core.dll filter=lfs diff=lfs merge=lfs -text
+msbuild_packages/Microsoft.Build.Tasks.Core.17.10.4/ref/net8.0/Microsoft.Build.Tasks.Core.dll filter=lfs diff=lfs merge=lfs -text

micromamba_root/Lib/site-packages/babel-2.18.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+conda

micromamba_root/Lib/site-packages/babel-2.18.0.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: babel
+Version: 2.18.0
+Summary: Internationalization utilities
+Home-page: https://babel.pocoo.org/
+Author: Armin Ronacher
+Author-email: armin.ronacher@active-4.com
+Maintainer: Aarni Koskela
+Maintainer-email: akx@iki.fi
+License: BSD-3-Clause
+Project-URL: Source, https://github.com/python-babel/babel
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Internationalization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: pytz>=2015.7; python_version < "3.9"
+Provides-Extra: dev
+Requires-Dist: tzdata; sys_platform == "win32" and extra == "dev"
+Requires-Dist: backports.zoneinfo; python_version < "3.9" and extra == "dev"
+Requires-Dist: freezegun~=1.0; extra == "dev"
+Requires-Dist: jinja2>=3.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytz; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+A collection of tools for internationalizing Python applications.

micromamba_root/Lib/site-packages/babel-2.18.0.dist-info/RECORD

@@ -0,0 +1,1150 @@
+../../../bin/pybabel,sha256=R2b185Ik-z2nEAdZdtycl4j3hRLIkSGvTgE4h8qnEVI,453
+babel-2.18.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+babel-2.18.0.dist-info/METADATA,sha256=ETmbwDprgf0g6LgoIzkgUqjblpqO8VA4Kwz1mWr89Bo,2222
+babel-2.18.0.dist-info/RECORD,,
+babel-2.18.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+babel-2.18.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+babel-2.18.0.dist-info/direct_url.json,sha256=PSEpCxSPo_CL_hMuFsCx0VuaPJYDtmtFh5ZI2tFfq0s,116
+babel-2.18.0.dist-info/entry_points.txt,sha256=Y2Cr1P3E8Yt7kqzvVz4wnTvD1H3-BVD4FOkVqHIGBfc,750
+babel-2.18.0.dist-info/licenses/LICENSE,sha256=hrrVdYx4WboGJR-PEu7oheyjE2mSPfsrh6fBPDY02HA,1531
+babel-2.18.0.dist-info/top_level.txt,sha256=mQO3vNkqlcYs_xRaL5EpRIy1IRjMp4N9_vdwmiemPXo,6
+babel/__init__.py,sha256=iAtaegCgnkkqd3t4mTON700DPw6YvOeVn-zdWKrGhEM,838
+babel/__pycache__/__init__.cpython-310.pyc,,
+babel/__pycache__/core.cpython-310.pyc,,
+babel/__pycache__/dates.cpython-310.pyc,,
+babel/__pycache__/languages.cpython-310.pyc,,
+babel/__pycache__/lists.cpython-310.pyc,,
+babel/__pycache__/localedata.cpython-310.pyc,,
+babel/__pycache__/numbers.cpython-310.pyc,,
+babel/__pycache__/plural.cpython-310.pyc,,
+babel/__pycache__/support.cpython-310.pyc,,
+babel/__pycache__/units.cpython-310.pyc,,
+babel/__pycache__/util.cpython-310.pyc,,
+babel/core.py,sha256=47mzcxFpj3j16ZV7VhvZOdJQWBo4rlutQBD0oqM6G7g,45775
+babel/dates.py,sha256=jRsuCS09RAsW8gqixQk23Ffn69FieZU85fDNTiAzL-8,76060
+babel/global.dat,sha256=o4ncdOHrpbYBw8e0F8jQe55B8Zk3DRDMLMcMdxdxFW4,461219
+babel/languages.py,sha256=vySUM88KPgjZIfp8F98rzg0eBWUxBp4VSv3daVZzQrI,2866
+babel/lists.py,sha256=AGtv7uAV6lz4bs4F9OBZ1zcMctNsC_w8_ClJJT7D4LA,4380
+babel/locale-data/LICENSE.unicode,sha256=tMCujvBPcFn5bOW74EZ_n-b22Bu-E1F3Ad_rlh-00LY,2033
+babel/locale-data/aa.dat,sha256=CI5kOVaXWX2CQoHT6AXhrOMwFPCiQyd7Wke2QBJ1UtE,2795
+babel/locale-data/aa_DJ.dat,sha256=VKjSgKVsftG91nj0-AQMYFuF_p4YAGfRkgAvycB2EYU,1112
+babel/locale-data/aa_ER.dat,sha256=6b6qROwoeOq0-batM1Z7Ji2gvGDogl3ODcftt1Jkm9g,637
+babel/locale-data/aa_ET.dat,sha256=piwFu94H7e-jPwd4ZaWiDc-j2nAH_GiC5UZ2IxMx7bs,635
+babel/locale-data/ab.dat,sha256=xeio1NLBNIAXcafnonWjO3w0zofwM-aKr0-RiaL7pRQ,95311
+babel/locale-data/ab_GE.dat,sha256=b5be2Uv1YtP-bkMasJMzoQPxJPNLFqifXnCiK8rCyLE,635
+babel/locale-data/af.dat,sha256=pO9_3BpJSQAJ3gZ_j6ZdUpGq3zqEv6CIZZ-CpJTXwr4,144732
+babel/locale-data/af_NA.dat,sha256=zif__TyNY44mSCYOCrrglsyr_H31JhBNPwSJftg8200,1450
+babel/locale-data/af_ZA.dat,sha256=6lT-mLg7LRtyAEhWhiF2xVtiPyzEa28U6hsFw_BMrZE,635
+babel/locale-data/agq.dat,sha256=JJbF6NFR9qwwQTrIyrLh04DFJniIqDuFsbmHDGu5ThM,16628
+babel/locale-data/agq_CM.dat,sha256=hYtg7pRw7J6TsYHvhlEEv7DqpyXoK3KS9DAqtYtgBX0,636
+babel/locale-data/ak.dat,sha256=L73y_ylhZy39SlEaAwA4jCqP_92qLvIlsagl-o2RlKE,116224
+babel/locale-data/ak_GH.dat,sha256=tM-OSpXWyBwZFfKPVStWBbFv3dwNj_7AqcBz4ONrOQs,616
+babel/locale-data/am.dat,sha256=TddfeRISFvzjTFpB-vH3gjSKs2r8iT3CYckrriibXZY,173260
+babel/locale-data/am_ET.dat,sha256=2VZDSh5bY9vLLuTqcKYG66p5OYlvPRPX58rpNTFWPok,635
+babel/locale-data/an.dat,sha256=a1gEztcqWoMLW3f5_jlDxcPsYY-ItHKVud7gjisrS4E,28050
+babel/locale-data/an_ES.dat,sha256=rQuq-zKj7-fCjY-5fGGoGJT1x60pAyCEAVEswXPnHrI,653
+babel/locale-data/ann.dat,sha256=fUenvOdPjqayLEiVDRNncK8SOBi9gAGAdxMuOATlsI0,737
+babel/locale-data/ann_NG.dat,sha256=0i2K6cv6eCurgFgwtiCr09hYwZCA1kHkQaKnDyCD86M,617
+babel/locale-data/apc.dat,sha256=G96W-ebLqQlTuPN3-VqSfAY-GF0K99c6uXHza5f4e2g,1564
+babel/locale-data/apc_SY.dat,sha256=tagFeQz8BA9Pc7RMqkce1ZalfKIBjqg0SR4NlpGQaaM,679
+babel/locale-data/ar.dat,sha256=yAijlkkaH-RgRQidvCyNBkpi9Z7OTC9cNfIbKo4n4gk,288582
+babel/locale-data/ar_001.dat,sha256=hRKDI3wzxO5T191MfSdCn_MZ6ckM2Rz_r__0JZqS00s,1707
+babel/locale-data/ar_AE.dat,sha256=hEbIYUoNE5mRLOVXhmkGsvT0NAcq-rxs51VIMMzG9LY,982
+babel/locale-data/ar_BH.dat,sha256=FoQ2c3E3TDqKcioarWBvLi_MllJmSd_56r0U45_gHWw,720
+babel/locale-data/ar_DJ.dat,sha256=qbNam_QAmhobsIUfJLCL9pe146SvcmNIE_L3cWpmkBs,698
+babel/locale-data/ar_DZ.dat,sha256=_Y-JLC5hincnxze7sGmEpb7N4JnBh7LdFdaVPcSMDvM,1263
+babel/locale-data/ar_EG.dat,sha256=qE3gLQ6BzLaBOPNJVgaBhPQiIL2kQ4AiD_jLl7o52IM,720
+babel/locale-data/ar_EH.dat,sha256=a0xJdGJYzGFzfvwxZVDP7yURlTm93FQSTQ5qp3XDMYo,658
+babel/locale-data/ar_ER.dat,sha256=l-WjJfxm7kP05-Hnr5PingHaKWJ46ScfW4KEBcwD5HM,679
+babel/locale-data/ar_IL.dat,sha256=O3UYAjf4BB3NdcSQTn-RzNjyj4kzTBhX3q7E8-9Aihw,1264
+babel/locale-data/ar_IQ.dat,sha256=7-DnoHqsoBDe-ZXe0rIcEotb-F_CFyChc73dwnXuUoE,1975
+babel/locale-data/ar_JO.dat,sha256=hT1z-Me5SOjul3BHFubcqlyEk9H57fwD4EFENddiVt8,1398
+babel/locale-data/ar_KM.dat,sha256=Zx5XtfTuRPiW6iViOjeal_Fq-18EA7GuERViMP1_mc4,1230
+babel/locale-data/ar_KW.dat,sha256=1wSXHTcgFKwhNciVS8IvGKvkzzqOIMBFykEJEQXdhEE,720
+babel/locale-data/ar_LB.dat,sha256=-SuXO6LdhXNi4f_PHNrlxl8iXX47perQ_oS19bwRGpI,1414
+babel/locale-data/ar_LY.dat,sha256=2OxSGD1gkiWPcaRHd1qQv9ifG82WEjGahKqhsoFXfnY,1249
+babel/locale-data/ar_MA.dat,sha256=hTOwsXC8tsJxBVlksxmAMlIkn4kK50juJa6TuAPFkp0,1559
+babel/locale-data/ar_MR.dat,sha256=Kq7uT5LxvYXnGWz-cVcI6yDNximu9hZIpoKydmVse78,1359
+babel/locale-data/ar_OM.dat,sha256=HVOqTfoH3JVTHJL-yDBiIafNfckU7CIcO_sIzXBffKw,720
+babel/locale-data/ar_PS.dat,sha256=F-HZRPcMe_tJ8r9V01h-7mQ0UKQxQmuWuXNSi94MVMM,1336
+babel/locale-data/ar_QA.dat,sha256=UKfLpyX856fNgeifdr22wXpDncirWJi9NxqfSnS-7fw,720
+babel/locale-data/ar_SA.dat,sha256=8WE8HwCwO-OT_G2JBSgmPWSzyHOdIA3zajXPbBZr2Tg,24787
+babel/locale-data/ar_SD.dat,sha256=f7aUKlrKmmC7ijTjVwn5r9m3mfZfEob1a7GHVCj4Qxk,720
+babel/locale-data/ar_SO.dat,sha256=4LD_gds2VsvxdFHpFo56CxTFenzNdvEkMofc4oTGBTU,677
+babel/locale-data/ar_SS.dat,sha256=T6eeWPeFejmBC7InKqg-6qmWoer1vjl6srHe_5ybkDU,700
+babel/locale-data/ar_SY.dat,sha256=u42uhje_zt806WlUMpp5sIdi1yjw3Yv7vYbl6aELsyc,1398
+babel/locale-data/ar_TD.dat,sha256=OG7NYtRrJiDeRt7HP-B4ta5ri-6fdSnYomppfy2A4ec,658
+babel/locale-data/ar_TN.dat,sha256=xO974NyO5T-pRs-5b55sfQFGIwU2Y4q3VQUeqtqWf80,1201
+babel/locale-data/ar_YE.dat,sha256=vu8wYJgzcJ1douKfKLx3-hAg1sjndD5_PTHWG_bzRL0,720
+babel/locale-data/arn.dat,sha256=JB-QfwCOVQbVrLRlq2LMxU6SHO-V4ZaU2_0W15-0Rfs,721
+babel/locale-data/arn_CL.dat,sha256=cf_JrdIAxFwbltVwtloNC9527Du7zaoBDM-_KmctSvE,636
+babel/locale-data/as.dat,sha256=xoTmhieoAVjw59h2-_pLp0wjfZPVvYMV6qDSJjLrjq8,209876
+babel/locale-data/as_IN.dat,sha256=bE-OZ0Y3d2-QtD23ztjluSsFk1_RFNYMFzKgBC3waw4,658
+babel/locale-data/asa.dat,sha256=zzPu7L8RV8SVEKqeRiGIoWLBCJkeS0acDh0pYq87qMI,15492
+babel/locale-data/asa_TZ.dat,sha256=U0GU10aP58LxCeqyjl69RQCZi_6tTQxm2vni6XVkoqY,617
+babel/locale-data/ast.dat,sha256=_Qeoc0gz1ag9MkmNIuv4ufVjk0fH5xtW4M7vp8ST4hY,168961
+babel/locale-data/ast_ES.dat,sha256=51kFxigV5COuiPiNisp-OBFYMith5rUgBmU48rGk7Hc,654
+babel/locale-data/az.dat,sha256=2EcwMc8qIqCW_F0Ic2XjFQthkCGyfLNzJzJZU99ZcaA,173802
+babel/locale-data/az_Arab.dat,sha256=IGBla73oKavlLHhtIW37idHxTkmQWZ-S8NE54b65d4k,7499
+babel/locale-data/az_Arab_IQ.dat,sha256=VsM0-KQPCP4MUw-2wMsBv-F467cr2Bup3jfxx8Fc3ZE,678
+babel/locale-data/az_Arab_IR.dat,sha256=ROb0gFTPwK5CcjpQMB7CJ662eld9sZj7IA6QMrvxgto,678
+babel/locale-data/az_Arab_TR.dat,sha256=EV6cNf3keBNREHkfF98GGZGOZz4L5dxf8pFbujInaQY,635
+babel/locale-data/az_Cyrl.dat,sha256=ru4QYee174toLQsGPJn-d6xe65FsLQ87vBV9AW0o4D8,35540
+babel/locale-data/az_Cyrl_AZ.dat,sha256=GRZjR-gp6JYeLNxoiAKNdv9bkTmS1bpYnRJ0c9YIGws,635
+babel/locale-data/az_Latn.dat,sha256=aK2ziytg5Ig6GYk9tVCq4BEyV6UYy9Ip7F1_i4Pq1jw,2258
+babel/locale-data/az_Latn_AZ.dat,sha256=GRZjR-gp6JYeLNxoiAKNdv9bkTmS1bpYnRJ0c9YIGws,635
+babel/locale-data/ba.dat,sha256=Ly1V4wBNM4KCDGtuy9oCug4fZzVNEFqXOI8XKhkWFOQ,732
+babel/locale-data/ba_RU.dat,sha256=8YcwUOx3h4BcSfUIumKJ4wcFyiSgBM74SqenVIQUKi8,653
+babel/locale-data/bal.dat,sha256=mYMTNzej_lac3GimNq9dYgLY3Q4RtXpEvUkQ-zfzVqw,12849
+babel/locale-data/bal_Arab.dat,sha256=25CVl5rF7FqKEeHzAmt0BccVI_ODqmMP86KqQ4i6PL8,934
+babel/locale-data/bal_Arab_PK.dat,sha256=sy4tpUtN1St5yFoTp8C6-vi2bFGPjSaG_zDbY16Q988,636
+babel/locale-data/bal_Latn.dat,sha256=X9sEvC7SU0VUFnapzFKUq0nvc1az1c9lHmrCPHPCg4U,116909
+babel/locale-data/bal_Latn_PK.dat,sha256=sy4tpUtN1St5yFoTp8C6-vi2bFGPjSaG_zDbY16Q988,636
+babel/locale-data/bas.dat,sha256=hts2-gooZheGxndoyiVM9NwFrAitthfb4IPr7TtYb2U,16673
+babel/locale-data/bas_CM.dat,sha256=WBq-_rOvkBnT5pBaCyq844LLSRReQzg2HM0u7GmhKKM,636
+babel/locale-data/be.dat,sha256=8L6Q0C4wjbLMC9I7ltFoY1prATuRd-8nn0udprYBI6A,272322
+babel/locale-data/be_BY.dat,sha256=yN4Rf2-HqinMscTfe4jKEYpsCEaddHce6K25ol595Ag,635
+babel/locale-data/be_TARASK.dat,sha256=93xDxO06nuAugpWjrnx6C5k8Fs26HIAolUcUPuoHhbg,104118
+babel/locale-data/bem.dat,sha256=zBh5HxY-hRgaQd95anmqMAPP0UVzSV7JdcuqtJ78t1c,5782
+babel/locale-data/bem_ZM.dat,sha256=nQvsLK0FOSlgf6wspQdbj00IveO62c2Mvxjzn4eHGSs,617
+babel/locale-data/bew.dat,sha256=mfKR23PSPyS0AHxbaSuMvufZZQlMICxDGuPv78MtDbU,122095
+babel/locale-data/bew_ID.dat,sha256=JWKbnUQc4ZsJYTcBFypK3gSyFRK6Kp8UFEqdytnPMnM,636
+babel/locale-data/bez.dat,sha256=_saESrmbxsbQnGLACykFIs-aLUC-N7IigpyPWGLBebI,16300
+babel/locale-data/bez_TZ.dat,sha256=OwcKelhUxQWu-8Jm9nf2vCay6-8LQvg-ueZSN_mrGz0,617
+babel/locale-data/bg.dat,sha256=ofd_Tv4onIP1cE1pVO-171ySR9JJXuHKzpWqc-vtLP8,227940
+babel/locale-data/bg_BG.dat,sha256=CERFyuC4Dw9BfAZapqaq69iKAp7rBXWNCkLWAL5tAhQ,653
+babel/locale-data/bgc.dat,sha256=gW0lkQNX_h1SATbqzIqe0twmGqqfigkbqo7gvBCG1AI,2493
+babel/locale-data/bgc_IN.dat,sha256=hO39nPiyUx1kfCdagpCQ8lzPLycjdfk59jFQgsd3Qec,659
+babel/locale-data/bgn.dat,sha256=8RKzmGYGYkn5IF7NHRgPtaI9ozwCeEKoUE4aXQpItKY,28964
+babel/locale-data/bgn_AE.dat,sha256=5jo7AWXMNdiiEf-RqzB5xRVj0R89NFdwq5RAIEAeeRE,636
+babel/locale-data/bgn_AF.dat,sha256=UXCb78n57adZBdKHEGnhbmeVYppzlSscVOWnQNxfJOQ,679
+babel/locale-data/bgn_IR.dat,sha256=iXxyPD5Z-ouDWFpOE2atoi6-HHGoD6PNaT9c-TH6x7o,679
+babel/locale-data/bgn_OM.dat,sha256=3O0CzFrjWxOQFdN6-lDhCxRngoXfadd_dwYoVyjK9jA,679
+babel/locale-data/bgn_PK.dat,sha256=gdVUcc-isHd9lf0S-AmFoPIMwDZ8ay6NY4o1udWI6Yo,636
+babel/locale-data/bho.dat,sha256=JQAEhmajFwUOKB7ACN1-ZPcoKcXJaq0-FhsFCVcvn_8,2875
+babel/locale-data/bho_IN.dat,sha256=UcL_aZq35dOHME0Fux9zyt9B6BOTxyR5UvaGWKLs1jE,659
+babel/locale-data/blo.dat,sha256=I0gfsGv80xf7do-oxzjkh2or934YxYgDMkM9RHf7UXk,168499
+babel/locale-data/blo_BJ.dat,sha256=LM79oUzVI4JtLYEUklfbQxoweFAslN9jS-Ex-dya0mE,617
+babel/locale-data/blt.dat,sha256=6G2E9osBy9OrG1iUKLD9cwcRk3IV7fT11iI8zFkLaeo,723
+babel/locale-data/blt_VN.dat,sha256=vpTQEJYssmuBUn_pYqx7ZtYONNNz02_oBYlDMdWqKAc,636
+babel/locale-data/bm.dat,sha256=K0dLlxoDfJb4QLwa_D0SXfrbD53Xed_EJ21843fY9hY,15798
+babel/locale-data/bm_ML.dat,sha256=PAGrUwc1S6q32DDHTu5LkePFXe_M_i_WxIY4oLuUnzw,616
+babel/locale-data/bm_Nkoo.dat,sha256=UiQ-oKSXYmbnUj9nNXi-9Afx2taBc5EiN-JM1huGOno,2805
+babel/locale-data/bm_Nkoo_ML.dat,sha256=PAGrUwc1S6q32DDHTu5LkePFXe_M_i_WxIY4oLuUnzw,616
+babel/locale-data/bn.dat,sha256=00cRKYrwyk5snhrekLj0TQBVzZlV_PjQ0aLlsApgwxw,219185
+babel/locale-data/bn_BD.dat,sha256=mVW90kQmhDcwzKmkmgNAt5iMq1pLWmNndNID9fspVjY,635
+babel/locale-data/bn_IN.dat,sha256=Y4d5tMv6rG2A1fTcfN7-cMeZ1iH8XuqdZgpEBUy_FTg,4035
+babel/locale-data/bo.dat,sha256=2eVqnOFPv04Ix-1FVPHlDQ9UVTQC1JtC7-5lQ89aX7A,20102
+babel/locale-data/bo_CN.dat,sha256=xOnyre81Z1IHnWV5mJH0x313h-ZWu84hIXcMuB50IT0,635
+babel/locale-data/bo_IN.dat,sha256=GvYCgtrOD5zYYsfMtVmkCv8-y6His8Lg7iuytEGjnMI,1307
+babel/locale-data/br.dat,sha256=rBs1Bp9H6Q4ECO2mouoJmnCW0ux5CLPx1zy32GvpkCo,272612
+babel/locale-data/br_FR.dat,sha256=3oVDdZd7Xf4Q-hwmYraF42SM_3NtvSoiZlmlh6gSNOs,653
+babel/locale-data/brx.dat,sha256=0L8rfQwjwtj3y5M5zzdEB10way4I9P2m8A2E0mTIcac,160164
+babel/locale-data/brx_IN.dat,sha256=NKuJh0cEhRQasy6JAGUi5HbqdnhhEFTQ_7osgtdG5Iw,659
+babel/locale-data/bs.dat,sha256=YVLbXGLHf6QZ9vYnCjxjO3uBImuYnoxR-cEuBPVbP_w,213968
+babel/locale-data/bs_Cyrl.dat,sha256=oqFwEFFfYqyzkVvswj8CR2B_RCb51Myv8jQaDDjz0u8,219235
+babel/locale-data/bs_Cyrl_BA.dat,sha256=oA7rsQckE_IxCpXXB3F3KWQwM3WZTR7WAdYxJN98oeM,635
+babel/locale-data/bs_Latn.dat,sha256=6L9SY85hONRHO4Jz389C2Ziy7llKcDoyVNiE96ozCJ8,1990
+babel/locale-data/bs_Latn_BA.dat,sha256=oA7rsQckE_IxCpXXB3F3KWQwM3WZTR7WAdYxJN98oeM,635
+babel/locale-data/bss.dat,sha256=n9LaBwBIJ7adjJ63G7Q9o00llhPJtkgmeEp08nAa4D4,978
+babel/locale-data/bss_CM.dat,sha256=TD7ixCHREfOLDsDJn8FY5YqGYH9czdEzdULCIl_0GhM,636
+babel/locale-data/byn.dat,sha256=qT32E4jh6H_qm7HYSsAbKmaKluaLrGNXNl3F3FivncE,13403
+babel/locale-data/byn_ER.dat,sha256=oAaZEqMJuTbMITO-ZO6gg8qjwROukzh5VgjtLp6rqD4,617
+babel/locale-data/ca.dat,sha256=CIT0-7X7_e8RKWRrhLSmG-aBC2D51-hvRrTV-7iBav8,184038
+babel/locale-data/ca_AD.dat,sha256=tsLumbhbbeXw627WKi-sQdSTFwNpcSRvJIEYcrOMqOM,653
+babel/locale-data/ca_ES.dat,sha256=T-zv3FfnCJA2WUQTeBADKV82ghY-r60wk8mXtD9wbnI,653
+babel/locale-data/ca_ES_VALENCIA.dat,sha256=7Q59_PX0VWyLsDkC-qscZ-dKJ9AFzz7kCzJz4fTdBWY,2976
+babel/locale-data/ca_FR.dat,sha256=5HUFYUl5QRaUMwJxGLIqUhDO4_wF_crrr346wJmEOZo,672
+babel/locale-data/ca_IT.dat,sha256=Zh2rtOq8MIDC2CQXWnhp5HOvPfXNxhRGnnZViOgc1Mg,653
+babel/locale-data/cad.dat,sha256=XxlMk1b9CWE3wERhhQQN0wxW7iq8Mrngb05RXenmaSI,2476
+babel/locale-data/cad_US.dat,sha256=FWV1sofgr9no5P9yBxNDLeKWoQd80XEYEilmLwamkSc,654
+babel/locale-data/cch.dat,sha256=J4S73psT7C_cXs1VNNYow47plBodQ4PKINC59kzvfAw,2430
+babel/locale-data/cch_NG.dat,sha256=0adhw9xNMlVEqDVKvHe4HCPtbjcw5NSo4ny_pOjl0-4,617
+babel/locale-data/ccp.dat,sha256=Jn_O5MwN6DMGxNrXUpdrhT_z5ZOYh3-Sm5yGUcV8bII,207292
+babel/locale-data/ccp_BD.dat,sha256=f00776fnI484B-mzW0rY22KNkzV6wtmk7uxrSK_x9bU,636
+babel/locale-data/ccp_IN.dat,sha256=jMJimrQrx-b96hBSLi8sOyHtYRwNZryt-he0rhwEZ2s,659
+babel/locale-data/ce.dat,sha256=yuopW5QCq1u8E1Rs0hEOv_y1uvbem_P3lK-_AvU5zLE,135403
+babel/locale-data/ce_RU.dat,sha256=NgNmp1uFnm2MT-s_yx_V8KuW1dSR6_SEWf4NcqrAL9o,653
+babel/locale-data/ceb.dat,sha256=fwgJPAV6TfvyavZUW-9pKeLUacMuH03hCkSkHdIGm8I,100779
+babel/locale-data/ceb_PH.dat,sha256=Z2zXPyNI3Yu3QcGL6lT1nIsl04vDDLFvyd9GeucDtqA,636
+babel/locale-data/cgg.dat,sha256=vgLxp4dDUjKyHy-36IvfaPEy6IiXbDiMKShuEKJuXHU,15621
+babel/locale-data/cgg_UG.dat,sha256=HZBma4MFuX2Q7sk-SOYk5OUkbMXWWr_tEInOqPboNYs,640
+babel/locale-data/cho.dat,sha256=hWEL5XrIWAnqjYSb78iPaj2xh34KDcPYAMc46S7ZLuU,795
+babel/locale-data/cho_US.dat,sha256=T3CacgkE-uKPi0CV7fbcCLTNfdjEco_A50vYciuXGGI,654
+babel/locale-data/chr.dat,sha256=4a6eJjX1JZ-inCk-J8gHJq1QtoK3FpOXhOlQMDbHjwM,187187
+babel/locale-data/chr_US.dat,sha256=wZE2RrJ-5jjUQa1RCJgL7hkXdsU3t91orD-ULDYMXSM,654
+babel/locale-data/cic.dat,sha256=KgrmFl1fudc1tdR_g39YkGR6bcIedQMFnUjh831VIhM,2732
+babel/locale-data/cic_US.dat,sha256=DvW1XJS1hEp_W_5ol0pIECeUb3RqXsyieKVS8J6caJ4,654
+babel/locale-data/ckb.dat,sha256=s6wh2TRjabPo4G64RMoQD_J7FK77RBwsK8R0TH1xytI,35553
+babel/locale-data/ckb_IQ.dat,sha256=Osgu1RAUf2yQpZ-nNBKMxTFJnH32ItLg0kVVzjNfmeo,679
+babel/locale-data/ckb_IR.dat,sha256=6wWzlZWn7oDmGIdnF7UtCfIcUgQ1zvMxtAcEw4bbM-g,1231
+babel/locale-data/co.dat,sha256=NbKZ99wTpG7Y64LnyxTQJIo5SYQaUAOybc68DN6IbUY,12637
+babel/locale-data/co_FR.dat,sha256=DAmwXn4n1mRSsT17-DcU0vdVSI_JfVR8oGOnj7hTFHk,653
+babel/locale-data/cop.dat,sha256=MAhXKI-x0mI10Vlgo35ZvUTsKkyx3yrzVIDMfya68rA,693
+babel/locale-data/cop_EG.dat,sha256=ggMojdy-Ua0lFBG-khgVqDiiyDqP6v8JKJzdp4hv-kU,679
+babel/locale-data/cs.dat,sha256=o7qnhuIqxpPIfD-oyVLsvpmhtRiIOzgJBoMaZvyvPL4,247800
+babel/locale-data/cs_CZ.dat,sha256=keaiqSsGtB_axj8FvdYDOCDmlg2PbQMI6qnW-2mFUTY,653
+babel/locale-data/csw.dat,sha256=a31wJpIkcegvNW9_O8LfIY4-HK0zpLn4MBUEBb9C3PQ,20303
+babel/locale-data/csw_CA.dat,sha256=aWccZHGNU7G4JJdlGRnqyqm0ROubX0rwI9SnH_EhAxU,636
+babel/locale-data/cu.dat,sha256=mlGQkibxBcukKPAJawHruBMuw21x1j42ebTnraxW55w,16865
+babel/locale-data/cu_RU.dat,sha256=GcbqgE8Mlglk5EGGSVcCR-Zb8AmCqHGE8cbmAUSbpdY,653
+babel/locale-data/cv.dat,sha256=BUqS-4RvAuycOlAm_k33eV98VCp5bIUmrWUqjhmsqls,198348
+babel/locale-data/cv_RU.dat,sha256=oVPRtcHzmRmkAy26Bv1jLiWmm0P18ruvHlCQ5F3IFY4,653
+babel/locale-data/cy.dat,sha256=-bN00WqRhdnCL9VdnGgtUtwbmZ7n2r96oZdLuxSP8KM,276313
+babel/locale-data/cy_GB.dat,sha256=dyPULIteKk9gP7lGQiDtsiH5QDqNdlxMdK__2dq90dg,653
+babel/locale-data/da.dat,sha256=Aw20nDcBvnWWpy2IYvg9S8hJVoT-gavJ_LokmwppLL4,171762
+babel/locale-data/da_DK.dat,sha256=qNTw1H8WXsV8qGBHxu6noCUOV3BcoR63ERJF8Xc86Ls,653
+babel/locale-data/da_GL.dat,sha256=9BNeKX1-U4NDr3pBU1ZnCGAasdYZjBMsvpdS5uTf9qs,616
+babel/locale-data/dav.dat,sha256=LBf1uH_Q7632sBVhZgQSrdn5LU2pyIU389h4LircJM4,15690
+babel/locale-data/dav_KE.dat,sha256=MfFFEDT6fib5be-EmziiEF0NAnEV6lXD7svYtHUtmn0,636
+babel/locale-data/de.dat,sha256=l6ABVg2zXPX9Ws9g2-Weve05S46ii0hnbuCViS6mtmA,178630
+babel/locale-data/de_AT.dat,sha256=OhoRvklFcyYUJXplBoK2rAITKRi6r81lwOaixIuffcA,2010
+babel/locale-data/de_BE.dat,sha256=wvdWykhix9Slofcjm2tx2aEhMjffmMLsNrd8709NIR0,653
+babel/locale-data/de_CH.dat,sha256=PH2rDxHA3lpTBkPMCwWjapEDJtgrkHhq2_pAdSKSiXE,4091
+babel/locale-data/de_DE.dat,sha256=SM44YjGlqgh7bKlXvUdt53t9hnCX5o46ujI4IrGPpeI,653
+babel/locale-data/de_IT.dat,sha256=ALPY2QGlR9-kphEk4KggHVS51fQwEDVRd7aHLIiP9fw,1448
+babel/locale-data/de_LI.dat,sha256=FnGRiippDTTFRFswU_4PblQruAuWuPEpa8cGbXPJpbE,1413
+babel/locale-data/de_LU.dat,sha256=QAkvLfyKmZdQVfkk2BbE2AMisK1i7yhRetcApqn4dxA,1067
+babel/locale-data/dje.dat,sha256=6NxQgBas9S5kmjbRcbcuuIIxKaI5_MlfmSUltxJuraY,15530
+babel/locale-data/dje_NE.dat,sha256=lU1vag_HJ4OrbYNYWFXuSdtqLwSlwBbvD6Tg-hl36e4,617
+babel/locale-data/doi.dat,sha256=JrHDjsVlGntLL6qYf9NH52BWAGCSGeGVaHg_rgUiGkM,47442
+babel/locale-data/doi_IN.dat,sha256=-q_oAqvdTizFG1DB_1p8sZVyjbaFFQ_FFPtNCyVn9ZA,659
+babel/locale-data/dsb.dat,sha256=KvZxymKZ5ZbxQ-4gS_uvnNkrYMYn3D-BKz0MGAn5488,203926
+babel/locale-data/dsb_DE.dat,sha256=Z2Dzjx7eXscEBEAb-ymvb1GKP4GVNCt5L4i-BYC_vrE,654
+babel/locale-data/dua.dat,sha256=lmO8ssPF9bIgTU2SM_SzrGWodmsGsmbS485uZNDasq4,4827
+babel/locale-data/dua_CM.dat,sha256=Z3vD8WEr2Wlqqt39anvKXVhz4_yBSm4t5BoAaEz9PgE,636
+babel/locale-data/dv.dat,sha256=-1zCv4GXiRHdWjQk0qXWNPSf4FX4Zp-Ij2jwgz5BsGk,2225
+babel/locale-data/dv_MV.dat,sha256=lvuU5gj3vDykU2ftU1_4Lza-130DB6_ZwylDrdb_GlY,635
+babel/locale-data/dyo.dat,sha256=w71HDmFfCuKN9nUJnuqpHR9DDAmPLkwIu9E0abhYjWM,9854
+babel/locale-data/dyo_SN.dat,sha256=Z6N-NIVcKkx6sFUm8LfN74usyZfgeI6swJL_A_XbBcc,617
+babel/locale-data/dz.dat,sha256=dbPhCcTpoQh6szaBA4TN5eCi3sbG1UBvlQQxtMGHLEU,85026
+babel/locale-data/dz_BT.dat,sha256=KWd6cypWse4XfXbY4BmTlxGjlnRksYNcQYi_iyXluKw,635
+babel/locale-data/ebu.dat,sha256=S8bggVknCbVHw5x9aJQGB9kUBFNcwj9EONHRNtbaWCA,15583
+babel/locale-data/ebu_KE.dat,sha256=GEcGqVmH0WwgP1BCsd9vnSGxGXl8ON4UPTRbyeaNDfw,636
+babel/locale-data/ee.dat,sha256=xJ5vpKJa546rTvKKQI75-HvYmu6VjEedXENlPSeDgCg,88730
+babel/locale-data/ee_GH.dat,sha256=SkQi-aVmtqi3S99DUTLQzZqUE4LrAIWuy25QuZqYAfI,616
+babel/locale-data/ee_TG.dat,sha256=7y8-rDvag7_EQtEObq3fpHaRedVmuEREnQwjktmLwgk,1168
+babel/locale-data/el.dat,sha256=pMPkYRvK3y4IF93Z-127ZF_-_P_QV-_460LgZAHCw9o,247970
+babel/locale-data/el_CY.dat,sha256=POPjzTYMuP7Ijf1S88cAFR0ge9Id_sSRNembKdhk2aE,635
+babel/locale-data/el_GR.dat,sha256=S32Cm-1ENgLL_lDecCDI4qDfyd3wlQ1JbUwOnW1whm8,653
+babel/locale-data/el_POLYTON.dat,sha256=lkcs2uXW6mWXztmsAXnapnSuQ6gkns1WwsVgrg-24Uo,14964
+babel/locale-data/en.dat,sha256=iUuuvOPD3NkEnkY0K6ipYXaJlU_dggEeerU5c1EUQZY,220701
+babel/locale-data/en_001.dat,sha256=1h_YIMaDGBLRbF4L34EAmSTm3ihmKctA2GmzG4loU7E,31616
+babel/locale-data/en_150.dat,sha256=cjKCV1ZLhNY4TvqJF8BXvQR1jVUBFrdjL1RKSnBa0vc,1851
+babel/locale-data/en_AE.dat,sha256=T2jBGVJpPTUgTICdaQnAVjSsYCVkQLfjabyStaPl2CU,4164
+babel/locale-data/en_AG.dat,sha256=POWSM98pRq9k7lqCsxr-MS9PA-zLoOVUKUcI9iXtKq4,654
+babel/locale-data/en_AI.dat,sha256=7iwWKftqPdOdWJ7v94jsre2ZIq2cDpbVGAs_ScBztbs,1206
+babel/locale-data/en_AS.dat,sha256=M-N7v6BuP47wkTFmv5by1w42IQCUiSqKbaVTXtnwF8Q,635
+babel/locale-data/en_AT.dat,sha256=05-bVy1aMFWZlHMBC86A7OVy1zlhJw7hsjyvIOjxE70,1309
+babel/locale-data/en_AU.dat,sha256=4Of5kXCe3oX5qViTn-q1ZD-50JSQ-Ly7xX_b6SFWSbY,19022
+babel/locale-data/en_BB.dat,sha256=J8vppKlBp03jJvVuVp6Z4GMc_N0BukeQ8f8q14y8fwU,635
+babel/locale-data/en_BE.dat,sha256=0JXHgqUIWZYe88FYC97spm2TqyIaNOwDJBt3LBmUF7A,1547
+babel/locale-data/en_BI.dat,sha256=AbdI5FjEqQLOMbBtD3wLW_7AccuOwY9MZUFpMF1uEco,1189
+babel/locale-data/en_BM.dat,sha256=cZE8sxf44ETY6nCxOgbvJN2RhABZrRaP8SjwsbSepuE,654
+babel/locale-data/en_BS.dat,sha256=sGvlF2LPwG5eVA3IuH8-4S5X7BrvQ5LcgZ8gfAkkwwc,752
+babel/locale-data/en_BW.dat,sha256=k5bc9gYBdl_8ZyCelrlS9ZenMzs8cdfl2MxeCnOAr88,2850
+babel/locale-data/en_BZ.dat,sha256=LJsn2M0RWMbxDmGRxs2lk2ZvkgoguwPf7oLBYQydU4A,2979
+babel/locale-data/en_CA.dat,sha256=u9gSGF_MnHeklexjpxBWfDQI-5LREnNkP7hAod_hNoY,37942
+babel/locale-data/en_CC.dat,sha256=34a3Vb57hT2reRvwn0Ud1nXkoYQJoPmaqh1n5qflFdI,1187
+babel/locale-data/en_CH.dat,sha256=Nfkwk2HNOccSH8Co5SWYnFdHWEDEpKNPQ2o9a67vt_k,1866
+babel/locale-data/en_CK.dat,sha256=gvU21BSAugpjE7CT3xnpHML6oRgHPaBoq7W11YbG-1U,1187
+babel/locale-data/en_CM.dat,sha256=r_7Yzep6S0ZOFvk_TORm5Qhi55yjehVQAotaLnn7igQ,1437
+babel/locale-data/en_CX.dat,sha256=lKYbIRS6r-WMUd1ewX7Q4TpX0PBVcsYN7Cs263_xosM,1187
+babel/locale-data/en_CY.dat,sha256=kQZfhQdPfdBeePOngn-4CpA3ZJ7Th-lmZ-jOrBe115o,635
+babel/locale-data/en_CZ.dat,sha256=PNwk-yPyyA7DZbmrwm_Bcrhw1jNmFF8WNWtHMXwdVsk,713
+babel/locale-data/en_DE.dat,sha256=oI3TmMDoQZsGddvDb0fbbwd_LdTeFbFPdFkZhst2q7Y,1027
+babel/locale-data/en_DG.dat,sha256=xtjjxkuFB7I4p3n0f4Evz631RtMQhIzpoYwUzOzICqA,1168
+babel/locale-data/en_DK.dat,sha256=pE7x4MDJvZGFnqQqXMCDWoMV3Ovu2qH-QO2oYNvgL4Y,2425
+babel/locale-data/en_DM.dat,sha256=gbriVhXcdXi5GWmpgWdGB1LUwI2yquuLk1khkzpo1UU,654
+babel/locale-data/en_Dsrt.dat,sha256=16L4-KZ6QNunAmMFJ8bSRppOC16aaHl1rtQN8zOCbbQ,38658
+babel/locale-data/en_Dsrt_US.dat,sha256=p8c_L5tEvzYmacz0tmq58Wsbfp9wMV_PBgz5R_v7I-k,653
+babel/locale-data/en_ER.dat,sha256=U1vYaQVwnVgfmO9l2_GjBnAhHrShbiHU_E-hAclDvck,887
+babel/locale-data/en_ES.dat,sha256=UzffO5tH8bSTRY69w0_Smf0vvOrwID6yIjLHdVUphFo,712
+babel/locale-data/en_FI.dat,sha256=i4gKdljmc9cXO-E1IT6JGmq2JsRRH71sKe3yUmkhIa8,2357
+babel/locale-data/en_FJ.dat,sha256=k-hXekogcQzt00qXdcWODsHbg7Vh9U8Vx84bERd8CHM,672
+babel/locale-data/en_FK.dat,sha256=r6OGl7mX4ep5aeFMlhog6Xr--kDKFEVhDcepSJBYZWw,1210
+babel/locale-data/en_FM.dat,sha256=88mCYM5_VDSYpJ_mV4AStjiDpKAo_1W7GbmKcI9f_sk,616
+babel/locale-data/en_FR.dat,sha256=BTiA_ltFmx1GIjAZJ6bCZ2cuucYc--keQ26NCyLcibI,714
+babel/locale-data/en_GB.dat,sha256=2qd2bKhxJeiwIneKwRmH89UCmnYfBdpOFvL02en-YKU,3440
+babel/locale-data/en_GD.dat,sha256=c2ap41e5x-OY5dEYZ5wD4ByRbEzlx0845R1lPBLnJus,635
+babel/locale-data/en_GG.dat,sha256=qhfvbRdldEA4467X0_8N09HwT1ZRPJJtb7Evpvbbarg,1273
+babel/locale-data/en_GH.dat,sha256=bBpzsHl9QhNAQ7hrUtKb6TwGvZYibXQwXfuJVgLMlZ0,889
+babel/locale-data/en_GI.dat,sha256=veSOVDagnkTwyqxP4u5mOkRG8_W4MCZ5ptMBoGOg9SE,1228
+babel/locale-data/en_GM.dat,sha256=jfHQeiMTDNgnIpx3WZ9hOpCR_LXCYLLrVN4SUakudi8,885
+babel/locale-data/en_GS.dat,sha256=4qjeVJPA9Crph3uHpcywYtsNR8S8ok5l38qtEHsIk10,1168
+babel/locale-data/en_GU.dat,sha256=WDR_uybAkUii6RHT2x62pzCLvX4bMstibEztBvLSuxI,715
+babel/locale-data/en_GY.dat,sha256=TDiVa4YSapsK9rjQN3ATnrj3m267l35pqRLI7r5bLFc,694
+babel/locale-data/en_HK.dat,sha256=meLPc5_3zahna_xycXEf75TrW5_4BHuqMQcMyoo1eYQ,2315
+babel/locale-data/en_HU.dat,sha256=6D4ZyheEpHTHE64XVpU6t8ddSWyYT4Hhfo1HEHzimZ8,713
+babel/locale-data/en_ID.dat,sha256=b8R7owdV-fl30WrUhFz-1YGHiFweaoYs_bBFr9pGhD0,3172
+babel/locale-data/en_IE.dat,sha256=ZNe5XFbdM4UnYu6KaGYHggQqzIVCWwWof5C5ktTsHn4,2094
+babel/locale-data/en_IL.dat,sha256=O4-JPTBiiLezF-iUSDu73id-0VWlSiE0ie8z9qRaxq8,1424
+babel/locale-data/en_IM.dat,sha256=u3JX9jrrsW_G5RQXHsQIGl6ikVduckeldeS_FjKG5Y0,1273
+babel/locale-data/en_IN.dat,sha256=2d4aWIy6Q72ExhZHnku5HKbKmSSavvB7zkflqlBsRQA,14809
+babel/locale-data/en_IO.dat,sha256=TOM0TxdcWcu1wyBXJxsrE-uCIZsbYTCmUkTdfCaOO-E,1168
+babel/locale-data/en_IT.dat,sha256=zp8h2lM7v7DPs_9F1CphO3UVNIYsdf1_8Kj9PPiafoo,712
+babel/locale-data/en_JE.dat,sha256=IxL3Ry70pMOXDbCwU6LZllHXZmg8XHbjocavEWvb9jY,1273
+babel/locale-data/en_JM.dat,sha256=Z9GFZ6aFGEvIEzlbOlA5bBBvxgcxXx6s_7AxPMp2Yg4,1666
+babel/locale-data/en_KE.dat,sha256=oJa3lUdjavkdhkMK_bcnJ08waK9lfIRs8mFkG0JYf-4,1458
+babel/locale-data/en_KI.dat,sha256=3yfkrwv7Yd9yxDNnXz9Sv8ghbDvqczZTAELr3uGNYn0,635
+babel/locale-data/en_KN.dat,sha256=cFebccXOrQo2X1zmHoHYB2vzXynoroYImJTMnK9j3h0,635
+babel/locale-data/en_KY.dat,sha256=slmSWk0IEz_UK7PfHX4KyHlf_iBRfuoOWVuEB0aKaYI,733
+babel/locale-data/en_LC.dat,sha256=jUYdKd248Jkj5XVxXXbvXnfxu4BH_3s4Ld-O67qbPkE,635
+babel/locale-data/en_LR.dat,sha256=ribT8_azFjDC8uzIsOwkGTjfgEiFlSG_wAb_wG1Fmnw,885
+babel/locale-data/en_LS.dat,sha256=2HtV3gUrynDl2mVvqywMfff8VnVjz2ryoNS7D2n5T9c,885
+babel/locale-data/en_MG.dat,sha256=dtMrsBqOpwQExs7dVukbUzWojz_6swx5Ng6OXdKxsSs,1438
+babel/locale-data/en_MH.dat,sha256=NZjQknLyokLgJRNPicAZ55_VoRCATz_WvAxMo_I-HOg,1368
+babel/locale-data/en_MO.dat,sha256=UJVR7td-vlRY_a36ZWbxr_PcK6egIUQSKoky3DeAmEA,830
+babel/locale-data/en_MP.dat,sha256=Sd2vA3CdR_GBw1vQQQBfKIY0asJGsVUwZ6gD-h7Or8o,1349
+babel/locale-data/en_MS.dat,sha256=BXrA3odGnWSeR6404L85ErqMKxTnRCZ16UWL2RpD7TY,1187
+babel/locale-data/en_MT.dat,sha256=sODJaESHndxdT9SYZcnESDA6G6oln6n9NCojeHhKvJg,1990
+babel/locale-data/en_MU.dat,sha256=SefoZho0XzSzzU_Y_-udWPCuRgz8ujdUVkL7hhzZO8Q,1438
+babel/locale-data/en_MV.dat,sha256=Spp5zsOCHzCeZOyUdYqXoqmSoIJ0pxRR3b3nI27jvTs,2034
+babel/locale-data/en_MW.dat,sha256=5d20Ih8j6iwBY545I4nObBWdv9FL37nE-ggfpGeXSVs,886
+babel/locale-data/en_MY.dat,sha256=nUwwM17W9W78nnbXGmrx2zComZQ9Fg_pu3va9wPZzvY,716
+babel/locale-data/en_NA.dat,sha256=-yNAAmx38RoVJt3YRH7Tp1xO9o3GsSVDU6uF_GKhGb0,885
+babel/locale-data/en_NF.dat,sha256=6LqhwHyOnkQA4TNvseuiE1a5Ov7DV3y46CZ0ENcibXE,1187
+babel/locale-data/en_NG.dat,sha256=dvbDZYdlkmhF-IU8M6s2p_kHswy8HhdmR3LLc4EhePI,1439
+babel/locale-data/en_NL.dat,sha256=dDCtXReh9uMfUOVqGWaWjfV1-dLe5_yj-o_HrKZGMeM,1192
+babel/locale-data/en_NO.dat,sha256=7PJnnryBa2El81rK1pzjj1XT6PADpW-P9HnL7bRyKzs,1010
+babel/locale-data/en_NR.dat,sha256=ZiUNBY0c1T3LQP-qGmtuxLW2Jfc-lcVTuWpB2jxfAGI,1187
+babel/locale-data/en_NU.dat,sha256=jU4HXz_3l5k-luPPsjZmZBsdOVB5ZfkN1Xuk5i2pduc,1187
+babel/locale-data/en_NZ.dat,sha256=z_qul-H3zQn0Q_lrrHceySj1m2TQaaJZd3QMXE31CcA,2340
+babel/locale-data/en_PG.dat,sha256=WV6D2yT-4GX6ftbnUkK-ihfNg8Y-ImX1Af56okx8LTA,635
+babel/locale-data/en_PH.dat,sha256=oPz_wDvxfCHBpkBUaZ0RiwtPrLtx-9IigR0TIK1b-IM,635
+babel/locale-data/en_PK.dat,sha256=KS_KXItkhkUULbKd9mHdWD9ok4WjZbVSXhU8e5u8blo,2074
+babel/locale-data/en_PL.dat,sha256=us143U1tPhG6MUHpeixIX-yOMwEilDV-tUaQ1XgsjMQ,1038
+babel/locale-data/en_PN.dat,sha256=qpEWWX0fvhzV6gcX_SHNbJW7E-5FikKwXrQAP9BWmXc,1187
+babel/locale-data/en_PR.dat,sha256=bpAu9yoeKxzQTF5Be7AfXtyE3wax0eP0m-Eu-Cr0jKE,635
+babel/locale-data/en_PT.dat,sha256=D1S2jptkyX0igfFWctmR1yCVruIR7IZaJKevAIrPRS8,1039
+babel/locale-data/en_PW.dat,sha256=--3_iiNqupR9R3ccq5foj9HzkADBEwBYdKE_AxLZD3w,714
+babel/locale-data/en_RO.dat,sha256=5_EIBj1QkBAnG-yAK1C2PVjeJh2a33SjlAaTglysxEc,1020
+babel/locale-data/en_RW.dat,sha256=Et3hOZwaSDECrCzypgYq1QxKxxnB3XYziIeEe_WiY7c,1438
+babel/locale-data/en_SB.dat,sha256=h9TJ69YThzzLGTh49BBEmRBxSiZhZpQrVJif0QglLVs,635
+babel/locale-data/en_SC.dat,sha256=omYtCZBrLl8fHuT6XInezdetV7WqWZVYriJRnlWKbTg,1188
+babel/locale-data/en_SD.dat,sha256=ozd3rV_icr8p2H9V6StOSMkoHBPNBsXsay1GMRWZ1zs,928
+babel/locale-data/en_SE.dat,sha256=96guhEOzGr2Lcbd3xZ4j7HTj-0H0oaGMQIbI9a_5g48,1502
+babel/locale-data/en_SG.dat,sha256=u9U5CLnqs0iJmSnMsPBHF71HQLpFM3siADzZeC7iaJ0,2096
+babel/locale-data/en_SH.dat,sha256=rBm_0zxjHnEVzs_CPCyuz5LpI9isA2S6copUuNbxCcM,1210
+babel/locale-data/en_SI.dat,sha256=kkeEkPnW48iNoiwNZb0KV29DPU0oVNuENTi_Wmp2ALc,1046
+babel/locale-data/en_SK.dat,sha256=r6hAr3NnR-tbXF7eA4QVgwe493o_wH-QzcA4xdlYoRU,1065
+babel/locale-data/en_SL.dat,sha256=4hJLAAnyuEVVQZ13NC7wZ0JYJQ3rvX0SsOAp0OoW7_U,886
+babel/locale-data/en_SS.dat,sha256=C4kpyEFjyKT9-6wt2pGl4125aN0Bp0wpcYBrr62nPOc,908
+babel/locale-data/en_SX.dat,sha256=7vESruRIiaBqWxuSRpIE2U6PgWwJ9mxgbjjH_XAraa0,1190
+babel/locale-data/en_SZ.dat,sha256=A9wkzZ5cFffcEf1FobYRPxR1EAFwqQvqELsqRpNleOg,885
+babel/locale-data/en_Shaw.dat,sha256=wU9fC6w85YCi9jeUFo-zofJuR14QaSehUJxcCOGfQik,4776
+babel/locale-data/en_Shaw_GB.dat,sha256=uAIWlJ5gr_NR6lncmMaBrjXUPhZ33rGsXoHz8hrd_E0,653
+babel/locale-data/en_TC.dat,sha256=UWqEc9zpN3NdS1dymbUv2iGKhLkH65Kk9uNFxdXGnOw,616
+babel/locale-data/en_TK.dat,sha256=qz4RHtHQ6cNjB8xW8_BIHdzW1cEcQuyJfdqFIybXAs0,1187
+babel/locale-data/en_TO.dat,sha256=OehJQf8kvWi7A-Rwo2hPjs1Z9pTdg7_Hyx_ewWxbLQ8,636
+babel/locale-data/en_TT.dat,sha256=L23iDn_zvh16iPE5uBlLCRvECSozqyzU9W2OcSjYogE,654
+babel/locale-data/en_TV.dat,sha256=3sj3NCjQg-9UOdTz7wDJRpjx57bI0bntpmx0T50OK9E,1187
+babel/locale-data/en_TZ.dat,sha256=5Q87mjSEaCMmWeWwtesb9lJw2tIWOsvyScG1CqSpWvs,1439
+babel/locale-data/en_UG.dat,sha256=aQLfdbfozsYhK3EG9JXVxsmT4B7UvfSzNBo7kO2WSsc,1462
+babel/locale-data/en_UM.dat,sha256=qd26Sl5bJTEgHU25hvskp4LMxvRJByLOSvUikqz0J4I,653
+babel/locale-data/en_US.dat,sha256=p8c_L5tEvzYmacz0tmq58Wsbfp9wMV_PBgz5R_v7I-k,653
+babel/locale-data/en_US_POSIX.dat,sha256=U8r77o6qQID3Sd5FiZqukSpQnq4LV1BDwHUeuNZjW10,1321
+babel/locale-data/en_VC.dat,sha256=ES4c4Xt6OvJDhxoAZpWR2HFbtyENOl9CrV7XFCBs-MY,635
+babel/locale-data/en_VG.dat,sha256=sqiVUOEtDV2pAc5DzGl76qV1mL5K-UWhMRzG-Ff6r30,616
+babel/locale-data/en_VI.dat,sha256=AGffygfBAafQMxKAAoxt6kwmbES4R_ybbXRV2tHpy04,653
+babel/locale-data/en_VU.dat,sha256=ji2cRB8B-c8uJR7L56HzbkiTR8eJZziVTMcEzuiK2g0,636
+babel/locale-data/en_WS.dat,sha256=gowKsveED3UIWyLgnSWxyE6qq87lH2dMgOVLDGCEcBk,656
+babel/locale-data/en_ZA.dat,sha256=uoSLsVWiMu6x-DYwISGhEwveg0kVsDwgnIhq2Jn0hXo,3411
+babel/locale-data/en_ZM.dat,sha256=8y814a5GtYcC5gvh3YBlcYf5Imr0yNEIV_v8jH3SXqk,885
+babel/locale-data/en_ZW.dat,sha256=GUDDEesQRkUuLyyDlnJ3MGlGzG-kDPxt8OTIqVRKDyw,3320
+babel/locale-data/eo.dat,sha256=kSIbuCrTJF0ZuNV8FzhyheJT33iKwteIHLaYgdfPO4I,101326
+babel/locale-data/eo_001.dat,sha256=3-tP9zaTDfbBBjpd2qKVIhS7WWbmtVKGGW_BmGIhrHQ,850
+babel/locale-data/es.dat,sha256=c62rMW3rHT7taFSTKPt8je50jtFex4sL8nvuVey9224,191377
+babel/locale-data/es_419.dat,sha256=s-JLmJhGKoIbnsjZm-6UXnDsAsgFhIKk9OJk7SPR_oI,27973
+babel/locale-data/es_AR.dat,sha256=rFeyqcUDLb3yYYWMuCP8R4O1n4rT1XCeayaIaoPaOPY,7087
+babel/locale-data/es_BO.dat,sha256=9zgEUshMb69M3LZS_3TOk4kGOt73fnB2UWWR7HPFAgk,1477
+babel/locale-data/es_BR.dat,sha256=oCD_7IoQ5w-C-YXpQ_wBcS0wUkcY268QDcg5y7Vo7KU,1207
+babel/locale-data/es_BZ.dat,sha256=Z3ZskA42UBcpOPDI66F6YBTvzt-g61PmxhiEpdGXpwA,1206
+babel/locale-data/es_CL.dat,sha256=tpiiCMc68Ab3YYDqi_zh0dw_IfsZmLciylujbf72XqQ,4848
+babel/locale-data/es_CO.dat,sha256=_ZNmqQnEj8EoNse4lJuK0Qrg1ZnPSgUVCPCNo7K6FE4,7436
+babel/locale-data/es_CR.dat,sha256=GknsR2O3LbFhHagGvUvgNgBVCVbXZxk-yzivTPR-Q_0,1308
+babel/locale-data/es_CU.dat,sha256=N-TqpCs34sjlEMeJgvrfOSpmnnlGxuuGtSBSaUKDbvg,656
+babel/locale-data/es_DO.dat,sha256=HMY1U9RiyiBlQKc_kUERQ-GHqWCgjaqrBY0mKUE9Gp4,2700
+babel/locale-data/es_EA.dat,sha256=V4UU6BM3pjbuEleLA_MaJtWl8IejNcHzUM660pfKa80,616
+babel/locale-data/es_EC.dat,sha256=i6oUe_5GL6b8ZnbnORW1csbq1-qgo6VN0Z6x9G2xIWk,2941
+babel/locale-data/es_ES.dat,sha256=fd1TSjdlf2lSMxwi0NhYGR2eyiABBaSJvhLlwLO46j0,653
+babel/locale-data/es_GQ.dat,sha256=a7A-hqM9wNt51_CdpjzU8aT9KEeMz165-MyhkWyqJOM,638
+babel/locale-data/es_GT.dat,sha256=zk_WqHmzYsoIAiErSYC9G62MlbgAuySSTAPZLtOX__c,4132
+babel/locale-data/es_HN.dat,sha256=71FLaDfVW5pgllY-BoQoPaDjJ4lvhs_Fi9EBmJQjZj0,3051
+babel/locale-data/es_IC.dat,sha256=hwey8h4GM8i25i-YZR_K-jvCij95wZqr0zdTIKauP58,616
+babel/locale-data/es_MX.dat,sha256=6jxhdWleuQwI_O1FZOl2I5DEwUs3oXjAhJhyBmBCMGM,25204
+babel/locale-data/es_NI.dat,sha256=cF62A52GuQD-QU9-jBmK_8AJ5pZ1W_nJ7NwraSAhMvA,1227
+babel/locale-data/es_PA.dat,sha256=fBNNQGv937Iu4OPHxSuYtPu8M-u6xhUmG0LtMbxDC0E,2775
+babel/locale-data/es_PE.dat,sha256=G6ZcerCUvlSGQmeysFNtMNJEZwPAerVqwOG2hHUpZ_U,7244
+babel/locale-data/es_PH.dat,sha256=fEMZmVPQb97bBjEtCVMLn9JUtosTePmRuQqhpfNYkZQ,1248
+babel/locale-data/es_PR.dat,sha256=wPOPeV-O9rnLzNHObqs9JEUo2ouyqmaiXqtsxHtKpWM,3307
+babel/locale-data/es_PY.dat,sha256=KXiw-rkQCdcoeTv0t0SnA8ioZrHQYfPxen8491aSq80,4442
+babel/locale-data/es_SV.dat,sha256=JM9uw_EVtB6J8bH_Nz0GL_yr6ehay4uAPm4OJIiUmfw,1260
+babel/locale-data/es_US.dat,sha256=ifZ5PL9mZhnqv3E6uRoRS2Sqlkgyz53m2RJs9wDcpMY,22533
+babel/locale-data/es_UY.dat,sha256=31KdHVEWnE6fWuHa7KOdTLcmlWXn8M5liZZMDWlaVrk,2703
+babel/locale-data/es_VE.dat,sha256=kyxdQ51DhLNf6dQauAPw4vOlpjftw9CQgc3yH_uAoKc,2509
+babel/locale-data/et.dat,sha256=eTq6nG039wKW81vnFtx-qzaWVo0wiUey2Y2ZUQLl49k,175652
+babel/locale-data/et_EE.dat,sha256=JpcyzIDpGwHlLSiInuYO3HfxkMEFsDPBeMc-B8Rj3MM,653
+babel/locale-data/eu.dat,sha256=lEQD4nzng6_Fmu8zQtkrvoFWV5AvUaCpOaAlv7vknt4,178023
+babel/locale-data/eu_ES.dat,sha256=ABS9lrwjRkWenVB4fNrwKpr0mOuMF_eOlOrSrobcDl4,653
+babel/locale-data/ewo.dat,sha256=tHyC9Uj5Gkz_nGEiTCFjXn3veej5z1GUhr-j-Dl2vgE,16881
+babel/locale-data/ewo_CM.dat,sha256=likxlZJqzYOVxcG4oSUQLTiH5DjGjdAFsJPIjnnj2Iw,636
+babel/locale-data/fa.dat,sha256=ci_F95dki3wTXhl10yqZP7IomDg1FHIOArxqTEMUEyk,192269
+babel/locale-data/fa_AF.dat,sha256=3lXNqz0r7fjXSYzqZBKGD5gtS0cPs-lx1ExY_s1ucfk,8639
+babel/locale-data/fa_IR.dat,sha256=nPuexwzRHDb9TFMjILK_V43sVIzbcn_fgp0msY3eFQ8,678
+babel/locale-data/ff.dat,sha256=gT8MoHYFJcGDoVjBCYPzsrkMTKylOjXkE64Sc0L-rvM,15911
+babel/locale-data/ff_Adlm.dat,sha256=GbwYyVBbA8SAJP-1BYMW4b3HXivgi8HvRDzIaKuJtvg,326252
+babel/locale-data/ff_Adlm_BF.dat,sha256=eYQLbHvxtEqcJCMbXSkqN2dRSuYHVc6Tg9kOUKayJQs,637
+babel/locale-data/ff_Adlm_CM.dat,sha256=b3VqkcWqXc7s1hCxN60dd-yBRXkcXfMMQ0uAJKmSsg8,656
+babel/locale-data/ff_Adlm_GH.dat,sha256=r1CRe9Z8kZ3B3PDxmZQbvgpsEcY3OjJek9Z_S8FBb5Y,1236
+babel/locale-data/ff_Adlm_GM.dat,sha256=ZM17aBc8xznEjoP4f7HRCHaKn-DIxCSDGkL6GvDYvDw,1232
+babel/locale-data/ff_Adlm_GN.dat,sha256=HWkLsTj8Sd0fWYuYysHhShl08hg0iAvSXhPjy-rUjB0,616
+babel/locale-data/ff_Adlm_GW.dat,sha256=vIUl_C4PZSWmypeEmnsAUbGN2dSquM3nEOdBs22_qNE,637
+babel/locale-data/ff_Adlm_LR.dat,sha256=277rY6zAWlxetFe0D0JpVEY9MNcQiJU9kt1jRoiXE7g,1232
+babel/locale-data/ff_Adlm_MR.dat,sha256=qz618w1XY_zwZ27nB6LBgbzsjsh4UinfnuOVx2bqLgk,1233
+babel/locale-data/ff_Adlm_NE.dat,sha256=waY1EIQKuOkVzrtJ-t-5VY7cK2uKL0SIBO0PQbx4x9Y,637
+babel/locale-data/ff_Adlm_NG.dat,sha256=9UdHELj5G90YopBKktxDyWVQyLxl5f7P3ToBElwlvCo,658
+babel/locale-data/ff_Adlm_SL.dat,sha256=7jLKofwQBRggP61keprrbfFGXvrcJPIOvwEVmUNjcTI,1233
+babel/locale-data/ff_Adlm_SN.dat,sha256=nGazz6Tun3D-XsO6SljxQeeBuzvAb1sBQw21IbkDQKo,637
+babel/locale-data/ff_Latn.dat,sha256=APyNmlFYRwCQOlboY58qsqiF57rrI3F4fHu-uQTdt4g,866
+babel/locale-data/ff_Latn_BF.dat,sha256=Nym5keR3dDPMJBFr7ZyW2cuuY-qTMkdHzXnIHSmfD4Y,616
+babel/locale-data/ff_Latn_CM.dat,sha256=rWaVAF6D5gv_hDhNmSGbcWGpPV7X4gp53FBMXyMjT-8,635
+babel/locale-data/ff_Latn_GH.dat,sha256=-kMvFNIQyikTD2dFakV81ghSR2H584AigLgtmrzlhN8,1231
+babel/locale-data/ff_Latn_GM.dat,sha256=1Air8sk0wb0McqLZXDWIYQeiKgPusBaVjr4zk54IaoU,1227
+babel/locale-data/ff_Latn_GN.dat,sha256=7R-6dXYMBdveo2-9Vc7CjIA2H6y_hGJVbfVGIaJUgbI,636
+babel/locale-data/ff_Latn_GW.dat,sha256=2kbqhzcDeSPQxefHxynmrv2tmFVnWdRNjO7I3AZ6lxk,616
+babel/locale-data/ff_Latn_LR.dat,sha256=MQxcDQnMZC5hN52abzqCjVIL9Z5mA9wOyTqGPP4Oj0g,1227
+babel/locale-data/ff_Latn_MR.dat,sha256=CDUb5owq0Ntsd2lIZJejvYxOjl-NOUPP-v3tgVj1_qU,1228
+babel/locale-data/ff_Latn_NE.dat,sha256=R8C0fI8ql5XpnT29CrwBG8rgdHB1AASDBSdvqIqIQ1o,616
+babel/locale-data/ff_Latn_NG.dat,sha256=00rtiYbJD_ci8-0M4ye95rzGpbyX8qQ-dmFFIajAtRQ,637
+babel/locale-data/ff_Latn_SL.dat,sha256=UaWOeokdbSoxG0JUyyGWkDyz70sXy-cZbc3lXZxmQK0,1228
+babel/locale-data/ff_Latn_SN.dat,sha256=mPVac9iCnwNay8c7Ko3uUvg48lfyfEZrvhpyEFFGmFk,616
+babel/locale-data/fi.dat,sha256=yr9FhmvZuEh0-H8Kx-8XWi-7Suo0K-esRZVVhXdMPxQ,204853
+babel/locale-data/fi_FI.dat,sha256=cpbJU4KKG8OWbmLnc9TKTdzmpoi2AJh_Pu1cHhDwVSM,653
+babel/locale-data/fil.dat,sha256=g0INTCXppDgjTGgBHy9hqQ8Mcw7G9K3XLTLyVshWuuA,144724
+babel/locale-data/fil_PH.dat,sha256=JjoZt3zNxy1X6RnHoxUKOMzT-xMh3tGZBRq8cvrBwqA,636
+babel/locale-data/fo.dat,sha256=4P7HQxbB7uhYUyAt1rFID1mHXUe9zlQBvWCt8LDRhNM,148411
+babel/locale-data/fo_DK.dat,sha256=HUuarLNFSsV_gN2fg-OqrPr-6Ry6KFgitCp173jxAOM,674
+babel/locale-data/fo_FO.dat,sha256=SLeNQ33QTZ92kXCzQcFfo-OgwZVFPJKIeRivuvz0zo8,653
+babel/locale-data/fr.dat,sha256=HvPCR3ft-_VxUpJsVp1wKU8aiJ7eCKZEz9XZVlM5jek,213357
+babel/locale-data/fr_BE.dat,sha256=ODfkJC5kWWEEkjr1UV8AaLtKKc4sPCUxlIGkEDkTr6s,1085
+babel/locale-data/fr_BF.dat,sha256=7piWVeMMrZ-YbO9MNqJAu7ZeIdueVnhg07eeMwJHy94,616
+babel/locale-data/fr_BI.dat,sha256=R4kaU1OtMcNIcibkw8OFGP6FaYMxt2uKMRyidkEqbiA,637
+babel/locale-data/fr_BJ.dat,sha256=sel3fdwegY5W4NRg32t4MuXoqpGqTAGO_ffCF2NPggE,616
+babel/locale-data/fr_BL.dat,sha256=n-MRZjeHNkRMwCtGgPZq52Lj0ijntBsxfskC324i2k4,616
+babel/locale-data/fr_CA.dat,sha256=Nu60QdYyJaiQnz1EbBLSWIO86Rf57q3FWoU7ywZMKQ4,72420
+babel/locale-data/fr_CD.dat,sha256=HWaY-wrLseHcf0fGlRkAWt118iQjRZaTGlqs7G23ZrU,1138
+babel/locale-data/fr_CF.dat,sha256=wxzk0Nf6_pKO2VDivQprUY9WvaxRSkrfQBoUE1UVrAA,616
+babel/locale-data/fr_CG.dat,sha256=zP3HTP-nqZjG-OD_DLrDEPPbB3t9g4T2kHVzI-HxhaU,616
+babel/locale-data/fr_CH.dat,sha256=DiO5jczUyCwTWpWSoxVHE6kLMXQPru-XotJQLDInjKw,2876
+babel/locale-data/fr_CI.dat,sha256=TrHL8hQRuJI3Auxe3aTHYa_rljyUvT_s0q-jdSJflJM,616
+babel/locale-data/fr_CM.dat,sha256=31oDAmeRb3F8a4fvVn1QJyIbrla04w8kfC4oQO0vwkk,1970
+babel/locale-data/fr_DJ.dat,sha256=Jqu2FOJQD41B6fLSBEc_Wf-dIQ-B6MWlT0m1buQnmxo,1248
+babel/locale-data/fr_DZ.dat,sha256=uOe9lbjO51q30G0UMs5nKrMLta5CtLW2Fg4dvsfRX3M,1290
+babel/locale-data/fr_FR.dat,sha256=bwtjtv0NG-lxlXO7fJd6r--l38WKaQmqlmn7PpXJdJs,653
+babel/locale-data/fr_GA.dat,sha256=rMwS-msXjMO5T5k1BP2B2S9B_dYvDHlP8HMS-Lq8XU0,616
+babel/locale-data/fr_GF.dat,sha256=x97-H7H0h4_MUTpjMdrkYB790vBvPKKxmnUTu-FOwLg,719
+babel/locale-data/fr_GN.dat,sha256=6KVlBWrF76ZhgyYg47F1TcR8_fbE5Ii2pJzPhmbr3Pk,636
+babel/locale-data/fr_GP.dat,sha256=W99xHjqPQj_NJ1X34ismj8A4xeZcHu_vyqH8tIwXgeI,653
+babel/locale-data/fr_GQ.dat,sha256=Ogf5NI4zMvbVROeIb8F6h1NxJNKOqY4fKU6G2SPJXDk,616
+babel/locale-data/fr_HT.dat,sha256=S2Vvt2b9Wu4dY5Tsd9xxFAx_RLcWXCGf_XeSSQFYbKQ,1836
+babel/locale-data/fr_KM.dat,sha256=ChLpzCyulxYg8Qmm5HK8YkK203GRSUEBNPSl8war7lA,636
+babel/locale-data/fr_LU.dat,sha256=0sYBhn8-9lvfOrU-ZEIbnO5v03qQOQq4wXCKp70b2sw,729
+babel/locale-data/fr_MA.dat,sha256=Um7dK7MvHkPB_h_r0pk47rMFCng1LWFgIekS7cDX9ZE,1098
+babel/locale-data/fr_MC.dat,sha256=IfTCZ89rqHzUxdKyIz86Zs_VUH2zc5JAvntdhyKsNR0,653
+babel/locale-data/fr_MF.dat,sha256=xU0grNJKWgpfArwpLt7vuOpSTSkyPx3o6gFkmZLCxd4,616
+babel/locale-data/fr_MG.dat,sha256=A9zYBbE6gIWuGDPxv92ReIcR49gtIEYaEkCj9ZONHHI,636
+babel/locale-data/fr_ML.dat,sha256=-PoWsHBtnaZisIOqZyaEFmwooRXb2R2xEMe6DYad_sk,1153
+babel/locale-data/fr_MQ.dat,sha256=45qWAev4p2ZaFVky1Qlrw5q907PDfbRJq9q2UACahm8,653
+babel/locale-data/fr_MR.dat,sha256=mVSOABz3cRa1-HEeUKW13sLw1ZR6PmB9h_DPfZsK4Uc,1228
+babel/locale-data/fr_MU.dat,sha256=c4ERuS1GI8h7waxcW6BRtloW7BThLlgqdYTf31Ioh_U,636
+babel/locale-data/fr_NC.dat,sha256=Su2DaGZPnLCaONmgosMYke9kH6dP8xJ8wJF6P5xrJq4,616
+babel/locale-data/fr_NE.dat,sha256=D6ghYGdDXlhaVQ5gAr8wWHxEHYR7mBs0QaiNL5nfxWM,616
+babel/locale-data/fr_PF.dat,sha256=oPN2EBo1hpLjlpDYPB51qEAx_4HNMWG5-Bh9JN6Kal0,616
+babel/locale-data/fr_PM.dat,sha256=gEP6Ay7r-p7uIjOGXP8eCa62yujlTBntENdeNd9KKes,616
+babel/locale-data/fr_RE.dat,sha256=pxNaLi-BUbe3E-Xf5ZXPoeut9NdT0D9OGEgmoSWZEr0,1055
+babel/locale-data/fr_RW.dat,sha256=gP8mpM7gx_X_9NKDm8B9PuTg83jwT5Nn3NOKPpVhi3w,636
+babel/locale-data/fr_SC.dat,sha256=qvz0N08LKCsPCPDZK1NmAhhzmaszBQ8mSlDbAsEwAoI,636
+babel/locale-data/fr_SN.dat,sha256=n6ijBmMl-ztuCLSePI-Q3yIyhzejn7KvRw5ZqjDoXsA,1018
+babel/locale-data/fr_SY.dat,sha256=tpDovgZ3aK7OumRwbntHTknV-tRL_HjcPK1aQINC-x8,1290
+babel/locale-data/fr_TD.dat,sha256=1H47veWKRj_iV9CxHMz7x7tfrL8IYdQaRWhTV455efw,1208
+babel/locale-data/fr_TG.dat,sha256=r_E5Vnj0Kb5CG16ApHFls4UreDeO7-o3uzpQdJjpbRM,616
+babel/locale-data/fr_TN.dat,sha256=hcGRJ2UjuFEFJqb1BDglGsXY8jCEIdM8--OrU3OqRhc,1228
+babel/locale-data/fr_VU.dat,sha256=FYYsiaoM8QZeClMnQzLiLZNXW9hULz-rCgRTYWvrIvs,1228
+babel/locale-data/fr_WF.dat,sha256=jn6VFRw_qpJFxpO-I6C9nhz_wRZ8cV2b2XRBgSzi710,616
+babel/locale-data/fr_YT.dat,sha256=x0WpQCLoqrLY3_nCF7JlcuekkoUtcpE4llC8kRmeRmY,616
+babel/locale-data/frr.dat,sha256=Itmd93DOwAMGcTkWE83BWDS1oXEVckX0EE6mSiOKyoA,102994
+babel/locale-data/frr_DE.dat,sha256=2ohnodzECbJBUTEta36Ts4amZKl2_LDhuD0-Hu5JBo0,654
+babel/locale-data/fur.dat,sha256=pvg46WO2uwbg27leWyWYXkoqYFiaE1u9Txsd_iZJeC8,32441
+babel/locale-data/fur_IT.dat,sha256=PpDH1opUDjndOtvpPadiOtITGyGxKZY0ziEhb-4HKbE,654
+babel/locale-data/fy.dat,sha256=zJce96OaCoG-oKfhQFisyjgVEK3pNVtF9RT-f9h7y1g,108200
+babel/locale-data/fy_NL.dat,sha256=I_M2hFVCAaVAL90yVMloW2eYmzO5C3NZztfEDAes3_I,653
+babel/locale-data/ga.dat,sha256=rx5MLgtNUisB9V7gu0e2dNyCXF2H9KhLVULuYvLNUh0,261523
+babel/locale-data/ga_GB.dat,sha256=NKphVJhmH8egga1dgfO-hSRVFhbxms2JvGMU3ybgj_Q,653
+babel/locale-data/ga_IE.dat,sha256=P948T1Tl4B7kL1T-uxii27q4IWO3yQQ5emTLv7iHvW8,653
+babel/locale-data/gaa.dat,sha256=W9tUKmjglnSUxVlpiGA0clKmagjmzgF1Fwj_UPmg8Ik,33806
+babel/locale-data/gaa_GH.dat,sha256=FF7vo24vzA2ru3t8py246uanyOqyoSkpD65F7KFTXlA,617
+babel/locale-data/gd.dat,sha256=AtSvR97H05LvFNLHpLsb7tOgKYaOjYvWFOLaDDH6xMk,280763
+babel/locale-data/gd_GB.dat,sha256=weaRul21diYZoqLk7SXacBy8GD1bH30cQO6AHejilPM,653
+babel/locale-data/gez.dat,sha256=6gIHA3BFc3-A6-dOq0pc6bqP2ej6kmG9Xvwa0EEhoMo,12743
+babel/locale-data/gez_ER.dat,sha256=MKpSW7Upkpe42Q2mbJStbjtnrW6Kyo8Tg0zXAxnHWqM,638
+babel/locale-data/gez_ET.dat,sha256=93QTSMihpcfFyRhttFplgAcsAhzrPjlbrz5HI4feRSc,636
+babel/locale-data/gl.dat,sha256=N2zvS1gg8f3l6SOLqIIiKCBsbxAcArFclISemEyGx7Y,153642
+babel/locale-data/gl_ES.dat,sha256=us8xWRQnNTO_KC42-FOU2cnLCNl96591qnxZ4exq5Fc,653
+babel/locale-data/gn.dat,sha256=2CbBgzd3kHlm8uIpKVV3yurmEXB_yNUfM2NKTFV95dU,2477
+babel/locale-data/gn_PY.dat,sha256=tArgCo85T_BUNmPc4sXVRz8X5wcHJmBS6XP0r8dPgA0,635
+babel/locale-data/gsw.dat,sha256=TGHS38pKauNWMdFFsCyCJ_9p17aLt14jMA56gxTDBM4,95265
+babel/locale-data/gsw_CH.dat,sha256=fQlRCd1MJ_gI6rcnkrU-lUE7ZM4syRLh-suMRT0DCOk,654
+babel/locale-data/gsw_FR.dat,sha256=vHNQ1q9Zyf6xLfsJpmqpaX1iHerMRt1dsJSPQdQDoTE,654
+babel/locale-data/gsw_LI.dat,sha256=dsg7TA7MECMrbTXC7i7zXIjrEoqrF2jZ_ckGiTMholo,654
+babel/locale-data/gu.dat,sha256=5A_T6q__RzuWdGg9Sfte2wOqRw_Adz-LJMJJzFJ87cg,208242
+babel/locale-data/gu_IN.dat,sha256=shXUMyk4ogB8uJPazALoReGyLqRXSYOeVBVMn313_Y4,658
+babel/locale-data/guz.dat,sha256=491I3x6EkMG0roSEKI3sHxtaweXWNXhXyk4vsG-LzDg,15427
+babel/locale-data/guz_KE.dat,sha256=Uz_x0_YFKJHDkSd46SvuIfO7W0c-uqYnasmmLNib3WU,636
+babel/locale-data/gv.dat,sha256=Ye3v_q7SrnCeiOVw1r7NRcTtUZ3RwOr1ZKs6skxYTos,3960
+babel/locale-data/gv_IM.dat,sha256=bXOsSoV303kSUECHz2xd5HhASRI-XCjqjxnxpk0Bt10,634
+babel/locale-data/ha.dat,sha256=fVfNqCuIXaCTV5E9XNMNVROCwgalJ8f4MKfEvKun3Ao,150526
+babel/locale-data/ha_Arab.dat,sha256=AUoCyyrZDTrf5SEZ2SRizimC11NMSCyonIkMRer1PxY,2197
+babel/locale-data/ha_Arab_NG.dat,sha256=oYJYqTkaDX2p4IJ9j3sEJT49dcVn_f9JyjO0rUJTmAc,616
+babel/locale-data/ha_Arab_SD.dat,sha256=7DD6pzCmpEdjwbTMAbAb_vJey6Qh0tIeSs8LjEpJxBo,678
+babel/locale-data/ha_GH.dat,sha256=Cwfuh0nEMJu4LGZmdOXJHp_5fZRdpTIODJ_Tpd83uPM,1231
+babel/locale-data/ha_NE.dat,sha256=glKzRtSaovyoiyBc-vjFbJ0wNuxfga49w_zeK3ANtvU,616
+babel/locale-data/ha_NG.dat,sha256=oYJYqTkaDX2p4IJ9j3sEJT49dcVn_f9JyjO0rUJTmAc,616
+babel/locale-data/haw.dat,sha256=aNXNxqponTYIxzV21MX0jIzG73qbhbNO6px2WGael6o,10375
+babel/locale-data/haw_US.dat,sha256=W2qJBTNdETpoN-Ue0UYbqyblj-gIbQNOUMr01RwJ2fw,654
+babel/locale-data/he.dat,sha256=o6AACO6FcY_o6bcUuLkcWgbWIT77K8N8BTBDLY0hk7A,217062
+babel/locale-data/he_IL.dat,sha256=KpQ8sod_QOZ94Tr0tfhlATzVVsrqXck6eq7txoQgCbc,678
+babel/locale-data/hi.dat,sha256=-uw13ozTXWlo39eLvIBYrfQxDROzFOdwmI5wXU66n9A,221948
+babel/locale-data/hi_IN.dat,sha256=UMkxSHgYSdX-hPgYa7rOOzft7xtJwcM0m5nTphUe9xM,658
+babel/locale-data/hi_Latn.dat,sha256=Dn0MJdILlsVYU9R5BJFSPGGr1a35jF4k9ebJMKLX69U,30945
+babel/locale-data/hi_Latn_IN.dat,sha256=UMkxSHgYSdX-hPgYa7rOOzft7xtJwcM0m5nTphUe9xM,658
+babel/locale-data/hnj.dat,sha256=ryXdpBMEUzFyZ_u_YiqAK689QOsEuUO_Auyuhty_4jY,2117
+babel/locale-data/hnj_Hmnp.dat,sha256=6GekZXtZVXtGcI_zk6NqXq3WxMnOx83IpRlJOyUws6s,746
+babel/locale-data/hnj_Hmnp_US.dat,sha256=OydEowg2bNVks5nd5ij7ZJqqQT0ztYv4HL1ZZ4gNajw,654
+babel/locale-data/hr.dat,sha256=kdzKpWmyLAIFw7D5DPKG7aHUQjYlM5fctcBLRoHeujg,207636
+babel/locale-data/hr_BA.dat,sha256=E_S8FRdn0yszTWFg9RlqTV5zEwCc7-qtod45Ud8LHyI,1188
+babel/locale-data/hr_HR.dat,sha256=PqaNYKNdTFgfgmeiINdYp2d3q8qpfkCUs1y4ZHmsphA,635
+babel/locale-data/hsb.dat,sha256=w5bDS336hxU-RChl4QgaayXgMgN_VBUh5GJXznPI_Bs,206887
+babel/locale-data/hsb_DE.dat,sha256=_ELT9KBswSqeyiwbcsP9nFY793FE8PQzEu_2w78Amro,654
+babel/locale-data/ht.dat,sha256=WTxEmIzmX4quBNzQMm0nY3afRvD44p7KBr19xZN_t3k,812
+babel/locale-data/ht_HT.dat,sha256=XR94sLQ8B6jF6SPd_4R6GGLmQQZGe8IoGSDnMYNIT9M,616
+babel/locale-data/hu.dat,sha256=dmS-7GInw1eGbifjgMyXc1m1nBg6dK6IOJIDoLb_Epo,147032
+babel/locale-data/hu_HU.dat,sha256=r3RZskHfUdk1Ba226wqBHAoRMXorlh-IkWLlnY_mBTs,653
+babel/locale-data/hy.dat,sha256=R6n2G8QdkkxlAxBgpTK7l-cPhwHg03vIG1pwmWVrCV4,202316
+babel/locale-data/hy_AM.dat,sha256=r1Bb6WWX2QxVlLP5vRVgox0HgoDOosA-h3oYKLeZMIY,635
+babel/locale-data/ia.dat,sha256=Wa4yDTDv9TA2Imo69v_49GqgV8LvQP1iuWGq6LFAMOk,133538
+babel/locale-data/ia_001.dat,sha256=fzAkHPu7PNj2TOl-kQcJLIdlEK6z-KfVFUVcy-YF5Zg,941
+babel/locale-data/id.dat,sha256=CfCCzK3VV98obeH7x1Ueax-xYczfCwextwJ7aetTQ5A,126977
+babel/locale-data/id_ID.dat,sha256=GvwO35RP_Y8vswE60ItYMQa7XUOBXGLk8tvL8kSJkY4,635
+babel/locale-data/ie.dat,sha256=9nzS8srJ9Mze83D7nKqXSlGvjOtu7utOyAJCLaffEm4,77957
+babel/locale-data/ie_EE.dat,sha256=93dmapYNE5HEAfIRwL_HjNV4fpCJhy1CseggbriCXL0,653
+babel/locale-data/ig.dat,sha256=ts_BawFD_ves9B7kX6GAIxwBY8FP4jNmkZidIdAVaDA,78550
+babel/locale-data/ig_NG.dat,sha256=2MR603ed1L8Y_aZhXPk7K7J8bgQPE4xvvpn8R9Jodiw,616
+babel/locale-data/ii.dat,sha256=WBkpukOuFcoryzq0QnHhdafGfad_u9vdJy0JO9vo-iI,7477
+babel/locale-data/ii_CN.dat,sha256=Vr_Oe23kFnz-EDfl7XeDv6GeTY0LSK-VV6UJpzU8yJE,635
+babel/locale-data/io.dat,sha256=laqBHV7QB933VjLibEOmRezXV9StwhKVzKvWp8e62YA,932
+babel/locale-data/io_001.dat,sha256=T6zZvvSVOcdpy3fhXbdPAWmHCvDTluick2U8_hUDu2E,912
+babel/locale-data/is.dat,sha256=r9gnQpf81NqPVskVKUiSGWa6VU3_NXzJcna1Gho28d8,163097
+babel/locale-data/is_IS.dat,sha256=f3tUj_oYhQ6_tGnn8yda4PZfqChiHmcZXo_nMDCtzSQ,653
+babel/locale-data/it.dat,sha256=n8pxKaMuS2ekD7EOSV-3PmVfdzm9NqxF5zA073x5itU,173579
+babel/locale-data/it_CH.dat,sha256=Tvtge1s4BcbCeKJmPBiSbtbf_qv8wrw3Eb4Dc1sF3dE,2942
+babel/locale-data/it_IT.dat,sha256=-e6EK0A6gEd_G4_BHlmd8_caQ-k_JrEemNgdA0czhsQ,653
+babel/locale-data/it_SM.dat,sha256=xjE63TohE8bjkNiOh-BhOkuB9YWpQ0n2rrBMJoAql5E,653
+babel/locale-data/it_VA.dat,sha256=wwsl_eAmNu9m2JPZnpBwFVh4gsk5AM9lSx8UAXhrMlE,653
+babel/locale-data/iu.dat,sha256=vZIG1AsqwcrTA6zfwBeQydVAn5qDQXT8yTK8wvbaVAA,3209
+babel/locale-data/iu_CA.dat,sha256=C449KxuskTW8w7z56Vv602QRYsQ90O0WbazR7VqlDa8,635
+babel/locale-data/iu_Latn.dat,sha256=oYsdWLomYvVJg6kIQIKYOdSGWyrEHftc2U9bZ0sHFD8,904
+babel/locale-data/iu_Latn_CA.dat,sha256=C449KxuskTW8w7z56Vv602QRYsQ90O0WbazR7VqlDa8,635
+babel/locale-data/ja.dat,sha256=86xPBOY1H1e0fLC6g_61R_ipS4QGbB9sXst_JwwdAWo,179695
+babel/locale-data/ja_JP.dat,sha256=o2pbFmlkEZjV7CHE9cYENYVv2kQA8texhNDhEecgQ9w,635
+babel/locale-data/jbo.dat,sha256=2eB9ymOoFb8abB-v7ISAGcAg4HEEMmpuseHIXFgtqkU,1008
+babel/locale-data/jbo_001.dat,sha256=wwLKEXJOwULYD-q92kQdvpiwW2fgis5YcsP2mT4tnT0,746
+babel/locale-data/jgo.dat,sha256=9X63SqWqQ7TK7Z2RKaQwFBP9sMog_4cQN5Sr_KBlyL0,9031
+babel/locale-data/jgo_CM.dat,sha256=1lDyjZLpK6fS6oSpfnVLdYd2IUgGlUQfF53BDdK7TLY,636
+babel/locale-data/jmc.dat,sha256=lRstulkfCj6kDI8VLH_3GS4awAqVsylMU1hvvWH7kJg,15374
+babel/locale-data/jmc_TZ.dat,sha256=fODp_OsVygbH0UoRsx4HHcXrde02bRKc-hy80sDkcK4,617
+babel/locale-data/jv.dat,sha256=SucM3ZDoHXO7PsbOYNLdx0UmQqWUll2i1hDqn-zJY9U,103138
+babel/locale-data/jv_ID.dat,sha256=G3zTSeqWMngemp5lAcghudTcv-i8egZS12P0-T1DNXw,635
+babel/locale-data/ka.dat,sha256=dIskDjc7ZdRZ1rGJIHxOP_47WO_cdjLDx4eltYETbUE,230234
+babel/locale-data/ka_GE.dat,sha256=zzw4NZBk8dsHIBeEzB3Vtf2_1nC4DhqblLoBUXfNHN8,635
+babel/locale-data/kaa.dat,sha256=KjLQ7_UT8pqVmgqy5BXJHe9hbPceKi6AIyefM4_0pYU,17585
+babel/locale-data/kaa_Cyrl.dat,sha256=zW7tFPX2CPo0NwR2o1DCKu8Tsvm-Aef9RAuy6AcaJXs,693
+babel/locale-data/kaa_Cyrl_UZ.dat,sha256=DugGAZvImbUSHvvGmGw0ekXXBj34vEjSkHhSxVXbc-g,636
+babel/locale-data/kaa_Latn.dat,sha256=zW7tFPX2CPo0NwR2o1DCKu8Tsvm-Aef9RAuy6AcaJXs,693
+babel/locale-data/kaa_Latn_UZ.dat,sha256=DugGAZvImbUSHvvGmGw0ekXXBj34vEjSkHhSxVXbc-g,636
+babel/locale-data/kab.dat,sha256=ykLRvdRtHpY8y7JDHOgC03KxAyvAfxzYQUl44CKKr6s,121528
+babel/locale-data/kab_DZ.dat,sha256=v6fd0kyletm1kfN2ibSUh6oddckpLHjPd_qrq6FQpd8,679
+babel/locale-data/kaj.dat,sha256=tKKi4eYHT0zEJLSHi2DefEGyTTu4RCKpnANu7NQhAPg,2696
+babel/locale-data/kaj_NG.dat,sha256=1RODrBAPxCrrlTgfhpdz-VxQkTdjJEJYHaJEsOgQsNk,617
+babel/locale-data/kam.dat,sha256=br3FOMP0rS2tAq1tSXwYq197v2XXHqWtX_TM-39QP1k,15506
+babel/locale-data/kam_KE.dat,sha256=8AQQhHQdaI4rBKXfTivg884XIDfZlbDEQM28KwvB2Og,636
+babel/locale-data/kcg.dat,sha256=dOZR1bP8sPbhD2Mk496Twz8MOivgGQoliuDMAWSO9fY,2549
+babel/locale-data/kcg_NG.dat,sha256=jCObRZa-t9Khgx_M8ps0PLbeit7rPCFtHeCOhtfCnOY,617
+babel/locale-data/kde.dat,sha256=cFVUYeayn6-kMX6PwQQ3J8rpHMql07_V7lSluInC2x8,15810
+babel/locale-data/kde_TZ.dat,sha256=2sfb3gejYM15YtZeRrc0AJgdaJhqgbVJ9c9yF9SlJmg,617
+babel/locale-data/kea.dat,sha256=o2awnBismFEWQemtUPASmZMVLlOkJNDtuD6egmvMatw,76097
+babel/locale-data/kea_CV.dat,sha256=LyzxPE6yP0f9hdD4uvu8CvEp8nmcmRDVuRI8YxBQ5wM,617
+babel/locale-data/ken.dat,sha256=PMrEuqYRQIhbpP2dPowHOL_NKKFpEBd8qNUV_NpZnDw,719
+babel/locale-data/ken_CM.dat,sha256=jNEojAAtQqJMkEq84kxHU5hGOVQCOW_hnGQScxycYMo,636
+babel/locale-data/kgp.dat,sha256=OKx1ZbBdHw75AdzrT-petm32Dj8wJdtUQH_oai7v0qI,184092
+babel/locale-data/kgp_BR.dat,sha256=FNSYAqPhkzoZzholxTydgasgkuw7jgxCfyKDbeRiLt4,636
+babel/locale-data/khq.dat,sha256=OcW4Zprt-WlTePo7DzquB-yS8vwfPqjaijpkrX5l75w,15753
+babel/locale-data/khq_ML.dat,sha256=ViqThOcZTHZBtebV8LJY-DXdWVX5jAR5pdlBrTKws2Q,617
+babel/locale-data/ki.dat,sha256=vffpb6Wy7TN__hZQH1SJYi81AxamhBnEK_XBCiF3OFc,15451
+babel/locale-data/ki_KE.dat,sha256=PNoxhP-WLxW2vH3fS8N9Nuy0tVimMP-ZAaCfLfnfDN0,635
+babel/locale-data/kk.dat,sha256=93jtpKcfiQBRbyeOyJgqETZXGOntosB2nGedgHShM1w,200871
+babel/locale-data/kk_Arab.dat,sha256=TBsZm6iLJ_dw2mNxDdQk95jELZ87mArNl12iktCwKwo,222820
+babel/locale-data/kk_Arab_CN.dat,sha256=HCoaBi32ENdpJx5usXdBR9aR__MHFeKV-wTo_53tQNk,635
+babel/locale-data/kk_Cyrl.dat,sha256=z3n_4vbUD_OcZhi9Tm8vkSu9h4RUgavZ_CFrujFbuWE,1584
+babel/locale-data/kk_Cyrl_KZ.dat,sha256=eaQW7Va1z2L34hs-D9QgrmyvOo4Lpy2uxxvxms6kL4s,635
+babel/locale-data/kk_KZ.dat,sha256=eaQW7Va1z2L34hs-D9QgrmyvOo4Lpy2uxxvxms6kL4s,635
+babel/locale-data/kkj.dat,sha256=IYeF4Uoeb0kfxooFLFcqmdIwGWbWh0MUfBpztTxWFEw,3373
+babel/locale-data/kkj_CM.dat,sha256=gqHwzVPG_Lo3svaIVe0Kfhj4DaKtstOxJJhUGvvpSbI,636
+babel/locale-data/kl.dat,sha256=D8SSjxLZliXOxyTxpC1x7jYbFQn4WbSV3lfotFFt3Jw,47570
+babel/locale-data/kl_GL.dat,sha256=c49k11GtBG8-vExsQNo_d1pFaQm0LYmXl7QcMSTEApA,616
+babel/locale-data/kln.dat,sha256=pldtRERWUhEOA85_zeFJfshpMl6gtgdELjGyNGtJzOo,17427
+babel/locale-data/kln_KE.dat,sha256=ZhkKgZ2lTdWAvWVOJEFlp4ASvjk2hcyTc2_P9s3mykQ,636
+babel/locale-data/km.dat,sha256=TueDML7PuHjlME0Bew9xgkFSFIxBOsJTzpMwyjyvuXs,176653
+babel/locale-data/km_KH.dat,sha256=bnykdq-RYJ0ZwajV5dFBVtM4anVkLjXutFdUxKByQ2o,635
+babel/locale-data/kn.dat,sha256=n0AHHLkpl4FIYeiSCEMDJF9mFr5nCgHcV8HSCOKz8yw,267281
+babel/locale-data/kn_IN.dat,sha256=rx1LJYeAP8xU6MIU3yhHLuije5OQWL_wzz5glztIdi0,658
+babel/locale-data/ko.dat,sha256=tYIinjTM5ZLw-AvWerUR8h4FRQ09LGfoRNyutl2iMLI,154621
+babel/locale-data/ko_CN.dat,sha256=U_q1api28ucaC-ABOBb822CgSq4nywhMN02uS7TCREI,1187
+babel/locale-data/ko_KP.dat,sha256=BCMOKQSzXNnjAUWfZZ8pbFoSDBed9tnnatyqIePNWio,816
+babel/locale-data/ko_KR.dat,sha256=CJqKij0oULIeCIG8McohdnhEsfJxUwmJHOpJY1bLrNY,635
+babel/locale-data/kok.dat,sha256=1pS0SXgetR-9DHtL71PAw2VIRp51a9KfxoSnw3BoxFs,179992
+babel/locale-data/kok_Deva.dat,sha256=EP15THeV74hd5G3DDXlwIHzxQvpECa67TioBGaur3l8,693
+babel/locale-data/kok_Deva_IN.dat,sha256=GiRy8Q6VCULzgIxNPFEZzABKOg13Un-DblBwXnBSeEk,659
+babel/locale-data/kok_Latn.dat,sha256=jVrQX1SeylbWO6B3ana7r9r1sRvMyOvBVwPfyXxB4uM,29867
+babel/locale-data/kok_Latn_IN.dat,sha256=GiRy8Q6VCULzgIxNPFEZzABKOg13Un-DblBwXnBSeEk,659
+babel/locale-data/kpe.dat,sha256=AHR_ZG1p518D4yulM_cs5E58iMsVXKk4Hi6k0V0IDhQ,1331
+babel/locale-data/kpe_GN.dat,sha256=7eabSFmszupn0IlzP6TRg1-7FZS9AB3JdBkDgJtIs64,1210
+babel/locale-data/kpe_LR.dat,sha256=4O2gzHn_orogC0qOiIyIox-JjyA73hEAe_fZ3Fj5tYc,617
+babel/locale-data/ks.dat,sha256=KySSApsfBfxM26TaXsK2gChd3noV1e5l41gUsaC3DA4,111691
+babel/locale-data/ks_Arab.dat,sha256=fzDL_rCiC-BqymPhF6GBX-d5uVkvZCE4e8JS2L8cjRU,850
+babel/locale-data/ks_Arab_IN.dat,sha256=-OE8PBigMDH8zQrxiaffmabm91Mi8-OVdDR2JEK8xPA,658
+babel/locale-data/ks_Deva.dat,sha256=weXN4SV8247g4MW8R7MHXM6sKk1qhf2Wmowls_zowAM,12510
+babel/locale-data/ks_Deva_IN.dat,sha256=-OE8PBigMDH8zQrxiaffmabm91Mi8-OVdDR2JEK8xPA,658
+babel/locale-data/ksb.dat,sha256=vbB4JVStmpZIu9_vi6f9-Dt40sN2wPvF9Y2JzJJ9oEY,15356
+babel/locale-data/ksb_TZ.dat,sha256=PvWBMUhpMhV27zE9BCEJW8oMqRXWK-6VwmSsXZDMTPY,617
+babel/locale-data/ksf.dat,sha256=IIgvqtnlTxMmLSk38JyZe0PA5gLEX86ZDcaVIULp7Zc,15952
+babel/locale-data/ksf_CM.dat,sha256=0OOsuUS0S_AUxUPySFQOZVbPcB3F2I4yzHZm63YypDU,636
+babel/locale-data/ksh.dat,sha256=M6W02xiGUibDW13RIB7psbwMA2wdNYQHz3Bp9XljhZ0,76781
+babel/locale-data/ksh_DE.dat,sha256=EhgYIJQaC3LGiWrcE2sdfUC8LOWJnciWORi_yoRkOvw,654
+babel/locale-data/ku.dat,sha256=beByrhXjB8iRhaNGxkQaxnUckutus3MJ61Pm-Ro8SqU,117087
+babel/locale-data/ku_TR.dat,sha256=LoNyoL-poYXgqejDzB9-zI_0TIJF3amwyzcs6UnHUII,635
+babel/locale-data/kw.dat,sha256=x5JFxfv4DvLd5Xnq5J7JlbcffhYNXwIn5-Jp3Q5QV5A,7242
+babel/locale-data/kw_GB.dat,sha256=ol7LWhJJFNoNkFEjtk4x1PpLkML9UbuVmZAuG47LokY,653
+babel/locale-data/kxv.dat,sha256=AMdZKJIlfkcpSetPdGRHX8LLN0O1s14NAtDzekSi01E,69503
+babel/locale-data/kxv_Deva.dat,sha256=MlejiNswS_LJAemj-vyEyvXc2SyminqNCWbaq3eceKk,86834
+babel/locale-data/kxv_Deva_IN.dat,sha256=Z43Yc1G4Bsmu7KukFfgXfIl1Cq2Rqa7RQQNYygE5Aak,659
+babel/locale-data/kxv_Latn.dat,sha256=XqtuF9yh0tBrDPoRpZj_1Mw-QUqt98klOlgZXh7qPus,693
+babel/locale-data/kxv_Latn_IN.dat,sha256=Z43Yc1G4Bsmu7KukFfgXfIl1Cq2Rqa7RQQNYygE5Aak,659
+babel/locale-data/kxv_Orya.dat,sha256=lsjWswZU3LWmYNE5tLn9cla-WSbdfqAoltC_OvxtR28,85964
+babel/locale-data/kxv_Orya_IN.dat,sha256=Z43Yc1G4Bsmu7KukFfgXfIl1Cq2Rqa7RQQNYygE5Aak,659
+babel/locale-data/kxv_Telu.dat,sha256=rXJrWxHMFrPeheoNt9NvKLzNoGLpNXiHpc4PsuS4tX0,88218
+babel/locale-data/kxv_Telu_IN.dat,sha256=Z43Yc1G4Bsmu7KukFfgXfIl1Cq2Rqa7RQQNYygE5Aak,659
+babel/locale-data/ky.dat,sha256=PAH_ov1xcnJAie5ltB3I_XAUJsrE_8tFwFlOjorRBts,179889
+babel/locale-data/ky_KG.dat,sha256=CdtjRR2iZgfG5pdz13MX-EHTDtN6BdLeZwGCmrZnrkU,635
+babel/locale-data/la.dat,sha256=nJ1hfe-gN1dlNH5qawfkwjv0bNzefm7UCEwnYv1O6ig,33837
+babel/locale-data/la_VA.dat,sha256=dhULocaXyJGitrljd1w688DTmezcmmY8YcoKsT30n34,653
+babel/locale-data/lag.dat,sha256=mtjtyLHLCfoUr4STtBqLXOxLnZ0igugTC9fZiyJZk8E,16281
+babel/locale-data/lag_TZ.dat,sha256=LlfEls8DDvoVp07MYnFdLBPUhkJs2kzwUDk45BZIO-g,617
+babel/locale-data/lb.dat,sha256=lUGm84DfwLgQ3vC0mL_foFf5dSZZKDTIuwCRf5BjgVs,135641
+babel/locale-data/lb_LU.dat,sha256=s0AY2-F7BqA4tMcRPjCfbzbXRbHsKnD6uIQGSkulCT8,653
+babel/locale-data/lg.dat,sha256=LnMo-qAcWHbbAuRmCTz4_nBGHgUx0aojWG7C8TFn__Q,15834
+babel/locale-data/lg_UG.dat,sha256=nyn_HKdBHGkHlbjlDX28L5Z9k59MKFqvmVL3vg222s0,639
+babel/locale-data/lij.dat,sha256=Ic982St82mPMfuQqqLswPtOy8LlglfcLYk_ftIDM65Q,129648
+babel/locale-data/lij_IT.dat,sha256=rtPerU7ltwkHHc7HErfwJfX8TDSCpTHvBzwKBdSt4x4,654
+babel/locale-data/lkt.dat,sha256=U_yXNWWJkqlepaZ9kS-FVOAHQKVmc0vhwgWgFRzXnqc,11180
+babel/locale-data/lkt_US.dat,sha256=ywWg9m80tNjumAxGNrBwYhXhc28rC4OSdyvkdXAKs5Y,654
+babel/locale-data/lld.dat,sha256=2JBQPu8T-cMVqzVOFs0Vz-0hU2RtHMyTvj0F8wPl2EU,95451
+babel/locale-data/lld_IT.dat,sha256=rHSiZg_-Ba6si2LONUCmQ841RxcX2p7V1jDSuwNNBg4,654
+babel/locale-data/lmo.dat,sha256=GYoR98Ap5hosG9bfENEA3sCkR-msF_KvxV2nLydjs9s,1659
+babel/locale-data/lmo_IT.dat,sha256=Xg4Qvye_hPNJLCTwoBuRMAvhtjQb8VlD9SaH_5hVG9s,654
+babel/locale-data/ln.dat,sha256=OHqUbo7M-600CtpOUNqq3B-Tt0_L3c2GgyR2xZhuMmE,23909
+babel/locale-data/ln_AO.dat,sha256=VNcFViSaGw3f92D60Uk7vxQ8i6Q9H1FD6paDpJh-r4M,636
+babel/locale-data/ln_CD.dat,sha256=Ao_lUWuswJgGHhVJYs2_Z8LyN4iqgYsAda8f9UarT6s,616
+babel/locale-data/ln_CF.dat,sha256=g5Jy7ovUkwcn0W5Ov5bu5SBc2iM4SWwUFwtzWzAAb34,616
+babel/locale-data/ln_CG.dat,sha256=jQld0yw63ufWbhlOt81wjf731zZluc2zWc1A65kBlAM,616
+babel/locale-data/lo.dat,sha256=hXtgT4nkqb8h669TsazfIFBsK23QNpcCZbqvb6SXWBo,189363
+babel/locale-data/lo_LA.dat,sha256=gNa7KRGYWI0h0PcHJ35bwnPskILOH-1jLjHCXP85jaU,635
+babel/locale-data/lrc.dat,sha256=GbK-bWw4TlGvGRyM4WxDujkUr7Gdz9k2A__fSelwEdk,13594
+babel/locale-data/lrc_IQ.dat,sha256=cy9DO9oAKI51NMitAb2MTbZoxtaAPzaYVGV0-xd0mGA,1255
+babel/locale-data/lrc_IR.dat,sha256=-ca4EmTX5VAi_5tDfimpevJFb-g8vAjgpe_jkDTDZWQ,679
+babel/locale-data/lt.dat,sha256=1h5TjFvNSuqrE3JntTmnLN9wW69jfkVakAIICcmoVbc,262613
+babel/locale-data/lt_LT.dat,sha256=j8dIQrFc0s77xJ4P-UGiDcaNqZW6CXOEiOh30FemNiY,653
+babel/locale-data/ltg.dat,sha256=qRaChoBWcmkL8As9MgCysSh58BP_F3US65EaA97ZgZQ,2632
+babel/locale-data/ltg_LV.dat,sha256=Gm8suGbSLaNGzzWPjuEKVdEqJH18ABue4htegryH3bw,636
+babel/locale-data/lu.dat,sha256=4TGAGkYbDHz6QAKQHHXoRkl0Wx-0LOiMkTjDgwJq0TU,15331
+babel/locale-data/lu_CD.dat,sha256=K3k0wMpIbjusgPC2W1q2sxyxynx2M78zOLjt4ikcoZA,616
+babel/locale-data/luo.dat,sha256=xJNSb25OVQogO42d-Jy2fR1FzeSfW9Swwt9Wat4EmsA,15201
+babel/locale-data/luo_KE.dat,sha256=jVUd3oO_U7IP6KmvSkVHYNmlCc8_-m2mpJMBaqArSFI,636
+babel/locale-data/luy.dat,sha256=pcTbaSctQyVgVVh4nXoXxMQGZa3Ip7hsfRN096zwEsY,15030
+babel/locale-data/luy_KE.dat,sha256=NVkQAtmDBXUws3KybnM706J3lwUc5fJo-YEjKd1zhiw,636
+babel/locale-data/lv.dat,sha256=s10obHsTYkBF99rADGvkxupv--JkRPQS2aM6sWvbM4A,201861
+babel/locale-data/lv_LV.dat,sha256=oS9W0pdiTNtMTeGOsef2K7Va2O6k-dQEtN02qCaAoFw,635
+babel/locale-data/mai.dat,sha256=Foj4spiHhuOjBZqaXQxZNCWwdCoslwB7KSX6nXQReu8,95488
+babel/locale-data/mai_IN.dat,sha256=DoclpHa5nlHcAflg286ycOjQ6trZP8uHThzcp37Y91E,659
+babel/locale-data/mas.dat,sha256=xxugbgGc3JxvM2GzV1vmKy1buszviy7NtSH-y6GdMZ4,16595
+babel/locale-data/mas_KE.dat,sha256=zH3Le4j03YNsPjt_-GL5RvPG0znnJKQ3ifbLhMZsoYQ,636
+babel/locale-data/mas_TZ.dat,sha256=VyRJlBqV_fukTqSR9Jxr-PujSA7u-MP9aXrJBVJCKiA,638
+babel/locale-data/mdf.dat,sha256=NQH9Yo77oyvxZj_93XIf0e00JDAoI2ydlCSS3klNgwk,2240
+babel/locale-data/mdf_RU.dat,sha256=sVnTxgzU2rEwl7P4d5UY6XOKv1XUCbtkEQO0cu2OlOk,654
+babel/locale-data/mer.dat,sha256=WFl2qQThWrilUbBaN4UJQb97ZrV3uOB4ZTO9kXsjtnQ,15426
+babel/locale-data/mer_KE.dat,sha256=WqDQTsO6BtbROdcj3p3omUZk8XB6HiJrIlCCj_wLPxo,636
+babel/locale-data/mfe.dat,sha256=n5lJPfd4pjC3xmVm123ivVpjg-WAkLQq9YONw1JlpTs,14835
+babel/locale-data/mfe_MU.dat,sha256=MHUOKiQPHuUbhT6hQXJEkpGDvTUyMV4btJTuiLhJQ4k,617
+babel/locale-data/mg.dat,sha256=9PbZhJ2v9RP2XSzwv7bBPTGlSNYJrUUISNkTwdF1Z7g,18776
+babel/locale-data/mg_MG.dat,sha256=uJbGeEzIn4Rh5Bh4hyV-Hs0_qez9KBeOi4hvfC3zkIw,616
+babel/locale-data/mgh.dat,sha256=ezIhzOd-qzUBRud5ZPjbtBBc_mON2HuKGu_okOahCbk,9753
+babel/locale-data/mgh_MZ.dat,sha256=aFZZ41qtARE6CeecCEx99tzW_fp-XfkAc10wpQ5YeGM,636
+babel/locale-data/mgo.dat,sha256=xyRaEmGV6Fw9nVfReQJY7KfgGwdnvQzScLiH0appsLU,3549
+babel/locale-data/mgo_CM.dat,sha256=Nsp33t4abZsKdDmIgB8tb08OsEh-7JXMY_JKCsd61zY,636
+babel/locale-data/mhn.dat,sha256=RpSxxevhvYxyX0dq1RAhIqoREyyPwKjsByXvOhQkAMc,693
+babel/locale-data/mhn_IT.dat,sha256=3UoH_l7yItN5qXKPaq6bWK_CvK_wD68zkxzLrCwxr9A,654
+babel/locale-data/mi.dat,sha256=ZlyyKSUJCtl7z94uIwEFuC6uBGWXOTM8F1TJLiJeSmw,85086
+babel/locale-data/mi_NZ.dat,sha256=RElP_P4F1HDHjSHsdt54vriFcz0TcIeT26pm-_dy-Mk,635
+babel/locale-data/mic.dat,sha256=Sp71dA3ZhTiiPTfk3b0Mm6y6CM0J-mGR0av-psrUGtI,1638
+babel/locale-data/mic_CA.dat,sha256=uZoBvRFux6M40HcGau7E6V0Pyxh45Bxi0SFngOxLWRQ,636
+babel/locale-data/mk.dat,sha256=xVJU-aubw2FQ_THzBUGd5LHR5IU1VjGkPOeRHpU-T98,216606
+babel/locale-data/mk_MK.dat,sha256=qlI1ZtLgyX2fcYS9pnTa8illdSnPmfNXORjws-H93lc,635
+babel/locale-data/ml.dat,sha256=tR0lt2uQuzmsBgXWIuRpz-AzD00S_OrvLc-QkiYAX-U,246736
+babel/locale-data/ml_IN.dat,sha256=VwCnSFs3oh7xo4-nS1HzWj_xICDzG6E-AW0Oxi6Lu08,658
+babel/locale-data/mn.dat,sha256=O3oSpnDd3Pt-dRrwdg1v245S6Iym3SBnZZ3gqOhQW5A,183647
+babel/locale-data/mn_MN.dat,sha256=qhJGIDXSglsa3BYCalsusoyiKgOj7PJ90Yi4ET2-nxc,635
+babel/locale-data/mn_Mong.dat,sha256=zqCuL28Sx1DS8LGqtC2nyTCoEpSFpF0vE3wvBxpHK1o,1726
+babel/locale-data/mn_Mong_CN.dat,sha256=WTF89EShdtBd0Vz62erFwl9KTG-GgEyzjjmKWuJCFH0,635
+babel/locale-data/mn_Mong_MN.dat,sha256=BTah7qfU9QayUb7evUKdF9c4Ptf4NqqO6SUeUql2Bak,12935
+babel/locale-data/mni.dat,sha256=aS_XIOmHRptFT_dTFuxgTvB2cEPKHJVVM_vtURTFo7A,12972
+babel/locale-data/mni_Beng.dat,sha256=7PTKZT_UE3WNiipyGHnn2SDNFNhAcqHhEJ8T0Y3O7gI,693
+babel/locale-data/mni_Beng_IN.dat,sha256=nAW_LfRtJqC6-ehdC8yyszjhibXqMAXPkuaz8POQav8,659
+babel/locale-data/mni_Mtei.dat,sha256=zdzwNyaRIil7lkjEf6ProQX0nwYlc5VF4r4gHNTUVTY,1720
+babel/locale-data/mni_Mtei_IN.dat,sha256=nAW_LfRtJqC6-ehdC8yyszjhibXqMAXPkuaz8POQav8,659
+babel/locale-data/moh.dat,sha256=FuywEiFRXQe1GUv9zPR15KOsZLr1TykmuglinLINTqE,1316
+babel/locale-data/moh_CA.dat,sha256=AXdrS_As8DrrTGs5IHmQwXoEXndFuoWoTGXPXcL4Pk4,636
+babel/locale-data/mr.dat,sha256=UG0FkufUtQ7qvzcK_WENRq6SgPy4zAcviYDQL-NrGY8,234157
+babel/locale-data/mr_IN.dat,sha256=HOu9QR1BLbciqF6BeTfWvD0L5Igwv5HrCWu9y_vNns0,658
+babel/locale-data/ms.dat,sha256=l_YQob4w4jdu0U-Z-eMYK2bPAyU0Xeekar0olT5G21s,114970
+babel/locale-data/ms_Arab.dat,sha256=9zretwvdo_9N3SIxLKsUtDVNZlmh0OhrPDxmtWqw22U,14359
+babel/locale-data/ms_Arab_BN.dat,sha256=vTEKSh0hjyiWJhf503-fwjADvTCN0AqRSzF6muL52JE,1335
+babel/locale-data/ms_Arab_MY.dat,sha256=w6ZZrz3qEmnsLsWtJA8rTohqF1cxctkzSj4WN0XHuHE,635
+babel/locale-data/ms_BN.dat,sha256=vTEKSh0hjyiWJhf503-fwjADvTCN0AqRSzF6muL52JE,1335
+babel/locale-data/ms_ID.dat,sha256=ZPgnDJgiycDHGZnN3Eg7OgZp1jIYtiZzMqm9f3LOtR8,3440
+babel/locale-data/ms_MY.dat,sha256=w6ZZrz3qEmnsLsWtJA8rTohqF1cxctkzSj4WN0XHuHE,635
+babel/locale-data/ms_SG.dat,sha256=jsfNag5WQWdejzh5hayA7_-IbY03MUVPAPDHUJyCZRg,654
+babel/locale-data/mt.dat,sha256=Xx_-as8jJEXOBAgfFX7vE6-2Qex4FWJ5rYW3DlCbu0A,49384
+babel/locale-data/mt_MT.dat,sha256=L5q5LizZQL0-FLj2U-wn2YhkpL3p7ZvjdyAvH1wwUG0,635
+babel/locale-data/mua.dat,sha256=N4zi8XyQdW_TmszNHQyn4zmia-MpCNWx_Vudoaj075Q,15861
+babel/locale-data/mua_CM.dat,sha256=Ib4K67KfndwGsoZDH0ehHA-F7V_SUj7q9VsK2juzaIQ,636
+babel/locale-data/mus.dat,sha256=zPqFwR9oCIJ0mA6evYwT75cWt_QBF-0eDZx1n6fmsDY,2722
+babel/locale-data/mus_US.dat,sha256=xcd4KKUIqBwSefSC0GGSDkvXL46eDWgWolJsGuSf654,654
+babel/locale-data/my.dat,sha256=9crk_2tyVPKBH_YWC_D0h8o1nbHH9k34e414JywM_6E,183534
+babel/locale-data/my_MM.dat,sha256=l53-D5YL-BbmLZYveFV2ISa4NcrSwTfKsRRc41Jd42U,635
+babel/locale-data/myv.dat,sha256=78-9U5eDf3V2q3Mj0MazIxh1n8sjyVjQ1O0Oyt5875M,16828
+babel/locale-data/myv_RU.dat,sha256=sncxwOpjfFkRASKHMP1ytKcjpF4w4GjU_JEVqXv84Tg,654
+babel/locale-data/mzn.dat,sha256=8Y5VGlzCxKXzBP5iFsyflLZSS1x0_3T8sqbwivfU45s,46144
+babel/locale-data/mzn_IR.dat,sha256=fjN1ek2fAzZyzFJpjX_MIc5oFOEqj7LS_SNdBOQS9ZY,679
+babel/locale-data/naq.dat,sha256=N07nsBSSEuNZ4feWvo7b4YWwbgjBwlxG9653O-OlhmI,15797
+babel/locale-data/naq_NA.dat,sha256=e5gAIOo7le-dVOAX_k2OW6gEyVfEUxcYDUJu_MBDY5M,617
+babel/locale-data/nb.dat,sha256=-bGHDSonSEdqfb2PxNC1_3jOHELm3CwV7xzEtpmWZUE,1330
+babel/locale-data/nb_NO.dat,sha256=J1UiN-AG900acMz4p0fBHtXDpS0HD6uGAi7gg9gOrsY,653
+babel/locale-data/nb_SJ.dat,sha256=XcK9_nKriUY_4k09kmgJalGTls-e5-YS-MCPEKLP8vA,634
+babel/locale-data/nd.dat,sha256=ITmP8mLDb63INBKlxe3yCZqRbvL83DrVBkIIAA_YjmA,15730
+babel/locale-data/nd_ZW.dat,sha256=KpZHrPr_0Ru0t9ojSK9ZiqGZ6-rSpvA7cX9C483ocRk,635
+babel/locale-data/nds.dat,sha256=q3dxEsEcdLTOigPQxhEXuaA4U03umMzIBNC4NkFvino,47839
+babel/locale-data/nds_DE.dat,sha256=Qmh5DjX65W58jXXXX3pxfxS_HVTJVavMspBPdph9sfc,654
+babel/locale-data/nds_NL.dat,sha256=E_EO3ylaBjJNThr211Yzefh5DRbkEFFVpbBMXIQ4U1U,654
+babel/locale-data/ne.dat,sha256=5Ob8IUrudfJp6yCzhHkmYC2mkVY1sd10I79pSXzups0,210152
+babel/locale-data/ne_IN.dat,sha256=SFloADZtyb42wygQmrMy7yx-aADGQECZJUey796oqnw,1292
+babel/locale-data/ne_NP.dat,sha256=LGc7Z5TRi0HRNQdY4bqPitV73gzTPWLd_g-6aPyvryc,635
+babel/locale-data/nl.dat,sha256=iGSLuhpd3RP4i7tOj5RU-vJ1KC_Ij6d5npxRBE5HisQ,149984
+babel/locale-data/nl_AW.dat,sha256=HYycPPe5HDhuP_zN89ysXR2AqjIbx_-XB2n0-TUPhxw,638
+babel/locale-data/nl_BE.dat,sha256=xHmyTOK9-rwPAH6fYdlPFZv-xinmTFNRN-LIGxb59HE,1876
+babel/locale-data/nl_BQ.dat,sha256=lZQzrmWsFTpiWwT9l6FakrNoll3QNP3drIMcxFkAy6Y,635
+babel/locale-data/nl_CW.dat,sha256=doEeLSsQVaSocP4jr5LxNrT5luSiG4hkgsMvoYjJBtY,638
+babel/locale-data/nl_NL.dat,sha256=bGo4nyjhqe1VtDHlP5EUmNkBKsViUSiH3h_ikXcPuRo,653
+babel/locale-data/nl_SR.dat,sha256=d-YXA5QA5b2Bh-WhxNTkyKQ4ROhuEg1CeGN5XmzWcZM,696
+babel/locale-data/nl_SX.dat,sha256=ciTQIntv0njAJGIUENzo6stN8yarfh-eBpmEzxmpJbs,638
+babel/locale-data/nmg.dat,sha256=NEWUb0RI43oeWByH9l1FvrLDvVQY6501jviEYmM_CCs,15468
+babel/locale-data/nmg_CM.dat,sha256=0A-cVUgt1l1ITnPRdcgWiQ68ZGqHDYd-k2wSc_nXnMQ,636
+babel/locale-data/nn.dat,sha256=E-Y0lC-8QKCXdc8CC_ZPN3bstsXsM3MD4Lu62XMMq3U,64042
+babel/locale-data/nn_NO.dat,sha256=98eWK3CBq5T_dI4a6dQH2TktRygMH0EnpO1EO7w8lVY,653
+babel/locale-data/nnh.dat,sha256=cWTTqJEXln6pUYON7H4PRrYr_uRWktSzcLGCC8jnTno,3530
+babel/locale-data/nnh_CM.dat,sha256=dt9ZNHX5ZQo-kcyT4-mVRCUiuzL-H2A9e0s0JrHwZts,636
+babel/locale-data/no.dat,sha256=xxkSV9bwDKWKK6dmGIaZGo4snfkON9eJUp3-uvlEC1w,191212
+babel/locale-data/nqo.dat,sha256=VQzcAnkUnAETAL8xosXBsQltlC4yqpSZNMkwtsWPRgI,109412
+babel/locale-data/nqo_GN.dat,sha256=3eOSTBaZM0RNLUDZFr__KTR_9iZoGUFq9M6bhtmHjcU,617
+babel/locale-data/nr.dat,sha256=ZHIIC8BaR5XBmnULOTfmAYzXmqImq5QmELqbFPKKQJo,2167
+babel/locale-data/nr_ZA.dat,sha256=e4_czqcyMye0qthJd2hzn_9inTS8WjjbFOzRJ3wAS24,635
+babel/locale-data/nso.dat,sha256=dsq0mvwg5QK35al0bVwZGUL961EuGS05vlFR5qb4HwM,6470
+babel/locale-data/nso_ZA.dat,sha256=TdOqVTzKNigLD6zOPR7W7QHT-Aw40ylsUE7bmMwgaKY,636
+babel/locale-data/nus.dat,sha256=4G1Wwsq1yWIew4nA-QBo2j8LmbqBTRZ0gCU0LYLUSUk,8215
+babel/locale-data/nus_SS.dat,sha256=Is_mWvnSS7j05Vk9RHcCfyLOdhOeOWRqgXDf8FGNEJQ,617
+babel/locale-data/nv.dat,sha256=7CBom-BDX6Wk2o878hmZ8DBY8QAS8Z99ExdmdVpq-vQ,721
+babel/locale-data/nv_US.dat,sha256=ak7j2GDaOMbAAmXQhfC9PRM8E9h_hJZL3UDqxqjCtoI,653
+babel/locale-data/ny.dat,sha256=XXvyFcRnNcH9KcAH1K7jzS5xLFsXMlXVW3yowhXPIO0,2152
+babel/locale-data/ny_MW.dat,sha256=kyhkcpqgIwSrUcfxve2OS2P9S1AfXItRHmy94K7cQ48,616
+babel/locale-data/nyn.dat,sha256=nVlbaYbL0QCkpVvX2rYYUFRsuI8BOjcReljkcamobSY,15668
+babel/locale-data/nyn_UG.dat,sha256=fEm-RMI6-PvIjbMUoZK68dTaiAmOqH1iDQBn23a6r2w,640
+babel/locale-data/oc.dat,sha256=0GZZe142JNEQ78GP7q1Sq7ZolzkVuvuK-QDCpLu4Z6Y,66841
+babel/locale-data/oc_ES.dat,sha256=H-3UJZkJCacW_BELiE_wXsXSVHp-dfxv59o3Hed8uho,33273
+babel/locale-data/oc_FR.dat,sha256=L80Ivl6dUpQJF4fAY1xaAeCRO9BkN0l6oCr8nRwogsM,653
+babel/locale-data/om.dat,sha256=wbIQO2bCc4PnuCB14zg9Gw9XW3mlv8D_D0C39SMnAnw,67446
+babel/locale-data/om_ET.dat,sha256=v0wHN7iwcuJN-iFgWFPrGdplH6P-0c8B2OEqYOEeb40,635
+babel/locale-data/om_KE.dat,sha256=DZ-2HywpH9NGEronFox-2AprzyoSg0xJAS62LNqZxcQ,1365
+babel/locale-data/or.dat,sha256=bdzcLCC-BRprtZBlm8pvQhvGKe2zTqjQM1JPQZrGapM,226771
+babel/locale-data/or_IN.dat,sha256=ur6a2cCdapMoKd-6KLXR2xAF2YU8xaueeW7UTPL2yLU,658
+babel/locale-data/os.dat,sha256=2ARxbjnZ_WYF6VQTsvXN4epcXlWpkXaVEhUNOJpAv8Q,14821
+babel/locale-data/os_GE.dat,sha256=8NgIdMuGlNow1dXmjW6y4xOis1_3raiXcj_jLBPirpI,635
+babel/locale-data/os_RU.dat,sha256=76MsfCZxiy_RXfhW7Do3Z8q4-jhp1hOXTBIsA6SlA-Q,695
+babel/locale-data/osa.dat,sha256=Ob-cu1978hig_-zOnB-PJW1_496aZ_yT6S7VTFkHoEY,4538
+babel/locale-data/osa_US.dat,sha256=qFfjNw8tVOdprzqK2wBlGH4eNMxDxDQqDDReucJZR-E,654
+babel/locale-data/pa.dat,sha256=pMTu_1agUQqVCaM7VB5fe9wM45MEsfVkDyzkKp6UlUE,202684
+babel/locale-data/pa_Arab.dat,sha256=VBfuWzoA5UdGbWTTG3cPAYL0ApWSup5U9LWBBh4bGUE,3789
+babel/locale-data/pa_Arab_PK.dat,sha256=1Si67Mz8DZfo2D8Ld0b5IlZpvnSMgg4W8_zZLrHrWQ0,635
+babel/locale-data/pa_Guru.dat,sha256=fs7wqdmuGaKQCCwGkT3lRQSKmf1dxG3jyLboZeVtPmE,1276
+babel/locale-data/pa_Guru_IN.dat,sha256=kpz873B1I65nfS3Z5vDLmmGliFVPlPM58sB6jW9nkBY,658
+babel/locale-data/pap.dat,sha256=EzSKg0e-PaX4UNpqi0JTYSjLYwqljGKI-uJLjR1uWhQ,28121
+babel/locale-data/pap_AW.dat,sha256=XZSGzQPijHNf5GjxUjDJQt88iD0ETRdZSTF8gn-1U4M,617
+babel/locale-data/pap_CW.dat,sha256=Mu-gCfh3bv9pzz9RrylMffuphhqgiRaODEZm6TtCpaI,617
+babel/locale-data/pcm.dat,sha256=BPyAoOzA7PpWZ4G9w2NMBzu1JqtXwnZbeCSrLk7j-Qs,161833
+babel/locale-data/pcm_NG.dat,sha256=3gBp38NIuVEbHlKAtQPQXJjT3DKvy7zvUqMAZS6pGzk,617
+babel/locale-data/pis.dat,sha256=aCXK39YyoYqy97wCU2idxYXLL9cC7myCIiJZeKgq-po,1510
+babel/locale-data/pis_SB.dat,sha256=-CDkXv_877c__o56bBeYHAAq2X9CcnKdI65DiE61_M0,617
+babel/locale-data/pl.dat,sha256=zWkc9nD_Ipzoj-nuymRuCLdWD3dG_wQicGQE5NpjSLU,227506
+babel/locale-data/pl_PL.dat,sha256=3s2XpVyaKha_K9MesXKD6sZNGSn1PVRtuz9XYp1xrsg,653
+babel/locale-data/prg.dat,sha256=vsad78h5dkCtaL_Gc-AGmXy3cc6Od1j4WCPGBdX6Tt0,17267
+babel/locale-data/prg_PL.dat,sha256=5jT2Yeek_e_MpGShmy2v-0WWhzQkQ0WsJQlUYfIOcfU,654
+babel/locale-data/ps.dat,sha256=2Yvun7eRlWEkh6Om_QxdW3Hq3AwyYqoM8n0418VjcbU,158607
+babel/locale-data/ps_AF.dat,sha256=sNE6bgx_nV0VWKa8InelUaFYSa3Fpx6byJw0KT4B1o4,678
+babel/locale-data/ps_PK.dat,sha256=ZtzTnH2thc6-J5PbuMOq3lPu57kbqDFxO53s7BSdVSQ,7119
+babel/locale-data/pt.dat,sha256=6Db_e_tQGLJop802pMj8aeNGcuKxa9iKTCZYBNM4crs,183448
+babel/locale-data/pt_AO.dat,sha256=49hMN9AJBDNjcsQw-nl-jY_VKHanO0PGfvd--OxqOxI,1022
+babel/locale-data/pt_BR.dat,sha256=dVKYp9IwRMbjZ_ee-eXFPudSuTRrROvbFzY3dYTYmn0,635
+babel/locale-data/pt_CH.dat,sha256=zAvD0sYytEquwzY8ZRbVCcy7DS2ZzUXofl5qXOixZH4,653
+babel/locale-data/pt_CV.dat,sha256=zOQn8d7--PKrhRUhQ5mPKW1Km6Tyh5JF8hstfxpITzM,1039
+babel/locale-data/pt_GQ.dat,sha256=qI1hvtuSHOev12ips9o3Vy78NJpOMjhkW625M60lqZU,616
+babel/locale-data/pt_GW.dat,sha256=SRxbFDIg9FwEjGjutRI9P1SeLiZBqStwSqPuHBFZwLQ,1002
+babel/locale-data/pt_LU.dat,sha256=z9aq0BTWEnk4lXveNpmi89TKcXN_t6Ud4A_C97uyOuw,672
+babel/locale-data/pt_MO.dat,sha256=shItJIIDrxwlcQhWLhlZG0uhyTlSBDcTag5ivxmb9TA,1635
+babel/locale-data/pt_MZ.dat,sha256=UZ1nkXS9CpiCM1IpOG5XpGK2QqM5mE5lAgRLTGAWl-4,1042
+babel/locale-data/pt_PT.dat,sha256=_H5DG5pOSZR_5gjjycrMBKaOJd_euwJln1pa3MPd1Mg,96277
+babel/locale-data/pt_ST.dat,sha256=Cm2HUxlGtZaz8IXX5Ohms-HYuKgazuBcOZBz5rWOzEU,1022
+babel/locale-data/pt_TL.dat,sha256=CIIDM_Zo0xiu4gXngxYtkYK6ldTNZMRaikSD_sAokMw,1002
+babel/locale-data/qu.dat,sha256=UueUbNLnx5ZwsqJcvzKUTdK5_wKBOmR2haCj0zhd4RQ,93300
+babel/locale-data/qu_BO.dat,sha256=7RUvNrmuLtwqP-qab667GocH_c4gIvpas3dbN1uaGxU,878
+babel/locale-data/qu_EC.dat,sha256=_5V4RYoPb3eCAA7jOCNfB7WZqd9sWP1E0tlF8mGeqFc,837
+babel/locale-data/qu_PE.dat,sha256=Vdd0fcK2dtFgyui3Q9NElHuJ841RI-T5l2UHeBq8MQ8,635
+babel/locale-data/quc.dat,sha256=dIAxk2IuDZhWTj-NKC9PiHBZOnG9ARyANdJZUfoVlJw,775
+babel/locale-data/quc_GT.dat,sha256=8M8KtmnsJiTCaf-Nl5X174Omtyc6a0ri07kysDC3-5Y,636
+babel/locale-data/raj.dat,sha256=qkuyRruXTTQLDgijSA0Equfz19Aqg0p5Mg0heaGKT00,2428
+babel/locale-data/raj_IN.dat,sha256=SS8GPzJu5j6nfXlDoX4NFPN2QScl4M0YNsrFmWklymM,659
+babel/locale-data/rhg.dat,sha256=dHahMWjQ_tUshtlLauqf9b4Y36LNJFGrMBsVmjBzlqQ,4611
+babel/locale-data/rhg_Rohg.dat,sha256=DAOuwC-7uaIuZtrIXvUkYt6YkxqaKpHOma1m0-XTtrI,693
+babel/locale-data/rhg_Rohg_BD.dat,sha256=DcLSBtf_k_f6B102-vbhBOjfzNZjiTDvEUdIOQfVc8M,1212
+babel/locale-data/rhg_Rohg_MM.dat,sha256=HspZzbytcZQ853Jstp-eFEdqSMAD3-shgjrdxY_KQrE,636
+babel/locale-data/rif.dat,sha256=4KtUTy4D-OsLftEaIHU2fw1NUhx0pwJXXie51jI3X10,49902
+babel/locale-data/rif_MA.dat,sha256=Qq7ZdymuPdjHeYDUDGCjMuQBRU7w5qGdgzzZ6wPfN2o,617
+babel/locale-data/rm.dat,sha256=aQ4MmwhjJbBakV6-C-6yjDvN8jvVa8Mk0ovdYgVkR9k,95006
+babel/locale-data/rm_CH.dat,sha256=JHAlYXMD9Vks43cU_gcSEQmqo6pogWPl_R4VMUK2iHI,653
+babel/locale-data/rn.dat,sha256=LwQTzbFINNeIhU5qJsEnh-raxcCDXVMGA6ZL95aU9UE,16241
+babel/locale-data/rn_BI.dat,sha256=r5Cweh7L4EAZK-qTmJuloWc33iXeR4IJUbknrl0XC3g,616
+babel/locale-data/ro.dat,sha256=13UpR66j-nQg4kbgGH4ja6ygDq1k3CCErykEWeeG8yY,200714
+babel/locale-data/ro_MD.dat,sha256=pUZY970zkBSBpVOIA3Ss-6vDJUF3ZCEWYNs4_LXcpAY,2881
+babel/locale-data/ro_RO.dat,sha256=lLYIYWhDUmq1EZ9oV5SETauVa_5uNN5p52dW7XeemRk,635
+babel/locale-data/rof.dat,sha256=Yafgax503CHjHvrc_njDTMVOOD2B36sRvWvDE99geMI,15473
+babel/locale-data/rof_TZ.dat,sha256=I_qwGjqqrcwUR_3UNydHOm_EiiLZYyRV0q-s1qfSSi0,617
+babel/locale-data/root.dat,sha256=QDYvctKQfBJlCMUl24Gf71HIZQq14_V1LcTK-6udwzQ,51999
+babel/locale-data/ru.dat,sha256=8WD_7_Tz0ieaEjXNlFQy8xFSfCwsVf_CUcoHyFfqkgs,305832
+babel/locale-data/ru_BY.dat,sha256=99UlyhoMWnfyhI5ltXGaJkycWLVfJ3FwdxyRm-yr6kM,676
+babel/locale-data/ru_KG.dat,sha256=X-iAT1QuQGhk1mIetpGyWqDlwiBskLfwqrK6ant1XS8,659
+babel/locale-data/ru_KZ.dat,sha256=P1_Gn3esOwDLL8sd8vVYbFA8J7QEsaDAWfZvDsn-WwA,656
+babel/locale-data/ru_MD.dat,sha256=LU12oBwr7MfPTzfs8Dx7uUZVgHin8ybX_oPHrPIJTkw,654
+babel/locale-data/ru_RU.dat,sha256=IVG440mXjphW6iCsKysZCW1Gem_z5_O0lZI6-R3oG_E,653
+babel/locale-data/ru_UA.dat,sha256=WYPDEOUjHl7mtejs302KAURq_ckDn6CFjH-IwmiFF6g,1210
+babel/locale-data/rw.dat,sha256=1KiBkw5N7hioc-ESs0oqgdyOaVdOlsNp1iIz7g3k83E,8418
+babel/locale-data/rw_RW.dat,sha256=tw-gtzH64PeIAmNGeobgUypw7RAyKITeFAcQPGY0MG8,616
+babel/locale-data/rwk.dat,sha256=hCqo5glP1WqFJrEGyW6r3t43NZ7bVHAOGFGDkUzeM3Y,15369
+babel/locale-data/rwk_TZ.dat,sha256=s9duai8NRoHwn8YpQrlMd3VDf6jtQxxcUmu9CIIMzC0,617
+babel/locale-data/sa.dat,sha256=8r4iZXIQ3vnGxlSmOtDhwM-T_iaYN4SXuTSdGh-2JMg,15978
+babel/locale-data/sa_IN.dat,sha256=ABNamoPpYRbO7bK6BGm0tK92kd7su7_OP7Di0wW0zZo,658
+babel/locale-data/sah.dat,sha256=Qlb3HEv5JslfLAkUjLJz_XdRdyLhloQ9uf9q2b_O6jM,39310
+babel/locale-data/sah_RU.dat,sha256=jHlseiwMbtN-IsETeG2dsaIn6OB2kqtAogazMnn0f60,654
+babel/locale-data/saq.dat,sha256=grj85np3tZzXQmLdtYQcu76ynQv5Jq__KIyaDECFIj0,15787
+babel/locale-data/saq_KE.dat,sha256=kN94cJJt8AT0yBRDqUPGoJtMZdOb2e-83NNsq8hmQ64,636
+babel/locale-data/sat.dat,sha256=K_IKB3mSsOkYuYDtbGW3lbGjVk4ctB56WWkJJvE0-mI,66131
+babel/locale-data/sat_Deva.dat,sha256=0EHZ6UcxsVOfi399xQbOkzaH1OU4jkZ10uqmmWnK8VI,1943
+babel/locale-data/sat_Deva_IN.dat,sha256=Bzh9Vmzia_8KLAryt9VqCl9ter9tKxng4b8oFYbYK6I,659
+babel/locale-data/sat_Olck.dat,sha256=mszOmf6B29mFbE6qN6Moy6SfBjwsjaCsbk75dJR245Q,905
+babel/locale-data/sat_Olck_IN.dat,sha256=Bzh9Vmzia_8KLAryt9VqCl9ter9tKxng4b8oFYbYK6I,659
+babel/locale-data/sbp.dat,sha256=1qHxon8_TpGGnLHUBzy5cR1mCEnZmw1EuYz3QLgnT-c,15609
+babel/locale-data/sbp_TZ.dat,sha256=chWs0tZniO53SbtBquTHGS6E4v36tgYL2b3enxHcdCU,617
+babel/locale-data/sc.dat,sha256=ItaljMMLxOEM4DEG_yDNVk8H4AmQrq1xCnDE8AfRDDs,189970
+babel/locale-data/sc_IT.dat,sha256=0G0vL9YXZQLkTmnzJuuygM5ty2Tw5liDg_aWHLvg32k,653
+babel/locale-data/scn.dat,sha256=UKMqekdt_t_Qe_ebhg3eaRsTs37ECpWLEiWSCFjMTLI,70373
+babel/locale-data/scn_IT.dat,sha256=dTXZIHDRhbFDCw02T0wL1iaJ2kfY1ZUzfbvUs4_WKLs,654
+babel/locale-data/sd.dat,sha256=VDMIluqNpBChcALvjd2lGll6sRK6srAF7p2CogEgXlE,154300
+babel/locale-data/sd_Arab.dat,sha256=jgkaYGUhPXll1T7CT68ridccZaERHeZdwUzGoAZBUps,879
+babel/locale-data/sd_Arab_PK.dat,sha256=c3AXdatnrTNDHW_SOh8fNNye4CVey81FnkSXwj7MmcI,635
+babel/locale-data/sd_Deva.dat,sha256=ZZathBrGJyoqspPsHF769J84zQq1y62vN8RAjGj_Cms,13957
+babel/locale-data/sd_Deva_IN.dat,sha256=0KQFEKHV6hHidc5hxrxQEvhO-YyvFf5P5z6t9hPenH4,658
+babel/locale-data/sdh.dat,sha256=5cD8u88qanpCtA8kPvHH9AdAi2-HbhznORqis1PYx6M,1032
+babel/locale-data/sdh_IQ.dat,sha256=B_vUMOiGWVcD1HaR4Zk8XxVzcmMFSISe2vRscyA1lYY,679
+babel/locale-data/sdh_IR.dat,sha256=hwMmQnne41X_lyjbyNbQq34Lpkl91bAgoavPZRuozwU,679
+babel/locale-data/se.dat,sha256=JnN5s3b1OrcP7qmurb8Rb9NKc-ICOr_RmdFs2EBKoRA,54830
+babel/locale-data/se_FI.dat,sha256=9_VJ0wzYFPto0YF2Ge0qieFV9_DOVqqYnPjlC5wnAr8,44207
+babel/locale-data/se_NO.dat,sha256=nm5u2VQ3ne0SUFZtFqwsRa8Gg97Xn1OSxjoP2I-i_PU,653
+babel/locale-data/se_SE.dat,sha256=6M9OxtmQAY_p9fZ_6L8zqo6i--bo_X00cvhTDEbX_UU,694
+babel/locale-data/seh.dat,sha256=viFuK-Mg4wPnvTcrvL-iEzNqFc7Ri_VP_r9pC673SNE,15433
+babel/locale-data/seh_MZ.dat,sha256=Sv94DueqrM3R5RjhCdwrKZsnNdL1WpjLBg6QhBnoaX0,636
+babel/locale-data/ses.dat,sha256=aRW4cH7nGNS5S3B3ff7o02GqcIqn1mVbBRGg3NdxXUc,15812
+babel/locale-data/ses_ML.dat,sha256=y14qGwP_r6VxzJhklYIWfYkolu0OHB-6nJ4tvF7J-iU,617
+babel/locale-data/sg.dat,sha256=ERl6d_xd8JRnkG_D857gWi2xONyI-cEmzt-Un_hXbu4,16476
+babel/locale-data/sg_CF.dat,sha256=QCNYqo_5l2Sv9JUFEWF6YLDR3MknhgkyMz1mO5j2Gv8,616
+babel/locale-data/shi.dat,sha256=fuYtv_xjgmJ0-aAQiuWcJXZY3mpeq__hz4lnouEUyWE,21830
+babel/locale-data/shi_Latn.dat,sha256=aQrfwwcvkgPaWFSev9-3WgwQXhhXj1_5myuR-QifnPo,15435
+babel/locale-data/shi_Latn_MA.dat,sha256=X8cwkkvm2LjcClQWzHRxxmiA8P0c37D7P8lf6RO4iNQ,617
+babel/locale-data/shi_Tfng.dat,sha256=VjsR4oSiK9oFfdIdpaVDwNSIBvFbQ3Jvm63K24bRqk0,974
+babel/locale-data/shi_Tfng_MA.dat,sha256=X8cwkkvm2LjcClQWzHRxxmiA8P0c37D7P8lf6RO4iNQ,617
+babel/locale-data/shn.dat,sha256=awBFmgdlHbpKsnUqWZaGAQ-YbTPm9UWkJKMn9IdJ7pM,890
+babel/locale-data/shn_MM.dat,sha256=7VauV3cmVfAJz7kA76hsF3FdwM75CVjvHdjx6lCoH4M,636
+babel/locale-data/shn_TH.dat,sha256=QHPmr3V4GzTbb6QA5SDl2EsVzQBjpbaDP6OHfJZ0S0Y,636
+babel/locale-data/si.dat,sha256=iuq-0rbecyzhX0pRX5UYdgKKzrn09pkLucKursW_Z94,216775
+babel/locale-data/si_LK.dat,sha256=cWCgV9WmnEwIIsBmhsIVzSzbrV8hkkXaV1xH1ultlUw,635
+babel/locale-data/sid.dat,sha256=zyKwuzw51B0E8sWg60qJ3kO4rzqTtcNBRnH5D3Zm1mU,2176
+babel/locale-data/sid_ET.dat,sha256=vtwy9BuaZwb5A3XdIl-3mws1cEAVk4s8oKy7i-GnM9o,636
+babel/locale-data/sk.dat,sha256=u_TnuG4-zvLxkxQupdNvPS-TYi28xeiPxLit28hxwZM,218242
+babel/locale-data/sk_SK.dat,sha256=eMjPq18mQOAXvkJN5WV6lKEAPyt7-eleGme2pHHevgA,653
+babel/locale-data/skr.dat,sha256=Mrx5bET3kh5Gzd8-2J9Rm4_b_wPZTDoHuhcxqdYj5hA,1702
+babel/locale-data/skr_PK.dat,sha256=UJpLMmJJIM5jeI-tXWPBNX4Qd3WS2nTwp3bvJg5D3WY,636
+babel/locale-data/sl.dat,sha256=eEJU8du-WwCkCviFmusUqH8H6sMl2PHG_khSumUB3co,210137
+babel/locale-data/sl_SI.dat,sha256=3Hk2t-MUfAUtqu_Gy0_fTjOhwBUtxdnndQ7Kowg0qek,635
+babel/locale-data/sma.dat,sha256=BaBVbhsEPN9V4JGtMt2TpMdf0oIrL8Maxt2FXDIEEss,944
+babel/locale-data/sma_NO.dat,sha256=OeIJ-EJtvWH6z2dZ1Hv8QdmQC7M7r51t-_C6LD6ZyxE,654
+babel/locale-data/sma_SE.dat,sha256=M_zYllAUd2UaWvccZ6ShB9-Gd8JYzIEln-88Q23syaU,654
+babel/locale-data/smj.dat,sha256=eyHR5AZqbxxlTYhyxJfvTjpz_v6zfh3TrDtcDkCgTig,939
+babel/locale-data/smj_NO.dat,sha256=5fz-YVJEoXswvC-RdFcJWmt-EMGcNXA3c9j_pfmxqCA,654
+babel/locale-data/smj_SE.dat,sha256=7l73FEZcAemOwXSrfPB3X7a0cto3J4oM7AO9i9PMIBU,654
+babel/locale-data/smn.dat,sha256=LGkyaifqt24L0NeExCtzhg8rKEKnkfJNEKtt67B-ViE,40399
+babel/locale-data/smn_FI.dat,sha256=VRY3dbCyxEmDUTep9bQXDRldd5wSg4skqQpztnMXplk,654
+babel/locale-data/sms.dat,sha256=ylATYbrfu8SVEVdQRbC7dTSOKCNSX7O1gjS2wJXA1tU,6521
+babel/locale-data/sms_FI.dat,sha256=b-Mk20lC32xysqU5v6jGjDUYDZaMDvoMwWOZNdT5yuA,654
+babel/locale-data/sn.dat,sha256=FNTHDspBYVPY7Nse1haEc19O0Sf3btsqNWQFs2Zzcgc,16732
+babel/locale-data/sn_ZW.dat,sha256=8HnH2raHHl8PI25abODlThEhjIOGXJb_u7cyQd5YzZw,635
+babel/locale-data/so.dat,sha256=sAFkgMg-qaZYhHT_lyoaggZ8UM_KX1xbS4miB3l5KN8,166227
+babel/locale-data/so_DJ.dat,sha256=VWnaj_MuW4dJnlO84t60ySCvfJL7FXI4nIP9PTL5Amo,656
+babel/locale-data/so_ET.dat,sha256=EvRRqU4yQPMYhkEK8a4MR808fwKHmW7EvPvEJdjltnE,655
+babel/locale-data/so_KE.dat,sha256=OSiRggRZ7CTNmqiGOvW1W2Cw2RqjVESTVOdUfgVgWyU,1208
+babel/locale-data/so_SO.dat,sha256=2IPbOqSxQGB5FukQ-B-MEme9FHYn22ClXmAV4x08pNE,616
+babel/locale-data/sq.dat,sha256=8lTejyAm-94ixpS6Dly7NQSHNsamftqLIdO4OxPWqok,160229
+babel/locale-data/sq_AL.dat,sha256=MN2RvkKGG2PXjCRsMHsvcnwnIOOp9tNSpcInh2uCWaI,635
+babel/locale-data/sq_MK.dat,sha256=L_GaZJ9XuQMs0zw-xZlrefPF36SH0sJqMrdDDbwicZM,1208
+babel/locale-data/sq_XK.dat,sha256=qILZGRwAhuIBJ9xi_T5WTrrZAVouFjQSvybrwgXTsog,1187
+babel/locale-data/sr.dat,sha256=AAE3LN_CLRWzljEERIYedZepxLIDWzENkL4wmu8Ib6c,265725
+babel/locale-data/sr_Cyrl.dat,sha256=Tbo90CyBAWciKeDesPhmXf7sdBQfjWsmyyrKBco_NzU,1990
+babel/locale-data/sr_Cyrl_BA.dat,sha256=sKEcBX9G9OwCmIZEpTphQyW_LM4xoDGe90s_470_AJs,41992
+babel/locale-data/sr_Cyrl_ME.dat,sha256=rDZOf-zykN151tfgGiO1SUJiClzQ6t40gF927bMLn1I,2320
+babel/locale-data/sr_Cyrl_RS.dat,sha256=Tn9u1EvJAZZEIdgXloi326qjpq8b1N087nRQ9R1JbWE,635
+babel/locale-data/sr_Cyrl_XK.dat,sha256=qVevTILYnuaIjRyPy4rDTavVg-VXxKcZ5fVdh5c-aHQ,1574
+babel/locale-data/sr_Latn.dat,sha256=1joKXYRv5UiiT21s_Za6qE-VA8XpFi1HzYnVOjKpxb8,217950
+babel/locale-data/sr_Latn_BA.dat,sha256=of4wpeCglVK_Td6HnHUjHRwuFtCVtWj3kHb3nl4B0D8,32834
+babel/locale-data/sr_Latn_ME.dat,sha256=Mr0GNVLFIMZpBakd4dEUzJUlAN4nyX2BMAqydgtMzWo,2089
+babel/locale-data/sr_Latn_RS.dat,sha256=Tn9u1EvJAZZEIdgXloi326qjpq8b1N087nRQ9R1JbWE,635
+babel/locale-data/sr_Latn_XK.dat,sha256=wIz7XXQrRFYpzMpR_cgSWikPWI0ehSx5a0gRBgt3rFo,1486
+babel/locale-data/ss.dat,sha256=UAB0p3UMDn8KfBY32a7HVWXWpHlPa26Nr_Woaah2c3U,2178
+babel/locale-data/ss_SZ.dat,sha256=X-Va1uVrsPa1ZX5hwhQ-ME6Q_bovUb24XXFS8UQ87lQ,1208
+babel/locale-data/ss_ZA.dat,sha256=xwT3vZ4tmKEvJpVwFMV9U2j2FLF1tC9PEDN6MC6Qbf4,635
+babel/locale-data/ssy.dat,sha256=QyBWLhH_sreFEBHMQ7aiqBsrGvDeQHyYAKioqksa2iU,2999
+babel/locale-data/ssy_ER.dat,sha256=9CRIaVxgOMeMTc0tcV0Yz9yZzq_uD3g3ylZzqVpYzsM,617
+babel/locale-data/st.dat,sha256=b-jiK03L_9F4QqWW8qmRJ3UZntZDI9eMJglRho3MN7c,8016
+babel/locale-data/st_LS.dat,sha256=pSzdNm6-O5V6-14VcgF2iGNYQPFYIXQlY3SqUW3GcjA,1227
+babel/locale-data/st_ZA.dat,sha256=5tdUX7dxXEL2xiS_0IvHvqhKF-gWXFsi4supkP0RDAc,635
+babel/locale-data/su.dat,sha256=G66EuouIQrCxgKGW9JzPfMZ94NAN87P6REyULyyrFGw,11817
+babel/locale-data/su_Latn.dat,sha256=ievzq_m7eD5pZWLnVlH7oMIdeadf8GIMqEuVPJTBjyM,745
+babel/locale-data/su_Latn_ID.dat,sha256=axNaukDpD_-G-_4R7P1u5w4dh-ToRPN_Yo-QpC1cFRU,635
+babel/locale-data/sv.dat,sha256=RTvQ2li9cKHIEbVl7fI8ENVrmcCa1gERk3S9O2bHKmA,198967
+babel/locale-data/sv_AX.dat,sha256=QFGzIe9UCr5gCpgHunvdPiZ-126vP7GYORL9jjip9-E,653
+babel/locale-data/sv_FI.dat,sha256=Pn3EDh-VD0QJFWupEZ6w4TqAa-WC5GZ8oTA4oqLazvc,2526
+babel/locale-data/sv_SE.dat,sha256=c9PG5p2y_4rnxepGD4uOzemBU3EOQhQNO4BtUS1m3rE,653
+babel/locale-data/sw.dat,sha256=w0uX0MB-_bZQWOnbdyDVg1uRVe1j-K-egjRExoZpE8U,145419
+babel/locale-data/sw_CD.dat,sha256=W7Fw8Wqwo3_x4hWlssmWbVTj4hhSQmRv8c-VSnQdlg8,2577
+babel/locale-data/sw_KE.dat,sha256=YMNWSTJ8qxo0d1KvQwAN5ECRaZ9LGc0BDfX4enggVlc,47036
+babel/locale-data/sw_TZ.dat,sha256=I1bDbpEDiR1jkCgJ_W9fWCPuPxMhjQmwG3sIueKb-Rk,616
+babel/locale-data/sw_UG.dat,sha256=kuNdg2N_dLwUKFm7wSheL1wLOdyrukPxLfDw0PN7tT8,660
+babel/locale-data/syr.dat,sha256=vuGk7MOpvWxjzuHSoG8mAJEKGbI70UoRq-DxlvwqT5c,111105
+babel/locale-data/syr_IQ.dat,sha256=Mrw63eJwh0vRe3Lpj0vRf6Q4cUZXJcx9tlWkuAmMrss,679
+babel/locale-data/syr_SY.dat,sha256=l0Yl2UMjm_7kuzvoG2-KqBp5XR88gdjf1ZlpRRNFMuc,679
+babel/locale-data/szl.dat,sha256=8PpGSXa6ES6yxXD2YOBjG16b6BW9jDZo86RKB0MCNn8,88759
+babel/locale-data/szl_PL.dat,sha256=1D5dKaG2l2Haxde8uraWI2J5lzw1dIWGeJtBesua-IM,654
+babel/locale-data/ta.dat,sha256=RRIrxhZ9pdpGShIrQx7ZQBOPKWn15OGkeL8yQOy-tz8,277264
+babel/locale-data/ta_IN.dat,sha256=BOFaDBw7fc7C6xSSFYNfkhCgCUd7ydHprJ6u0DaneSE,658
+babel/locale-data/ta_LK.dat,sha256=Od6ln5oUnWfaAHwt_SDafWv844c7A7_7fTT2OPVTuyw,1208
+babel/locale-data/ta_MY.dat,sha256=PEUmjhs_RUr1R5kH9uHExdnG59Hy8LmbU18vXZYYPtA,1325
+babel/locale-data/ta_SG.dat,sha256=tbuefTSiXPMwpeV085Qp53l5uDHLsMMXmt8TPEG2fWY,1344
+babel/locale-data/te.dat,sha256=oRTQlv5dIZYav2aQWijvc2wm0VwoR1TwWUPL_qhzkuU,261668
+babel/locale-data/te_IN.dat,sha256=LICnXU-D0uhvxVpQ986Ul1JeAQktXaX53sXZSUY3L2g,658
+babel/locale-data/teo.dat,sha256=jJ-266Aw_zTeJjwGj_VASqzm6Y3CcQYkVPXKuV_kzT8,16012
+babel/locale-data/teo_KE.dat,sha256=S_lAg36VkA1w384kzPfXRLmJmGWfmz3ll7MzOQAtcr8,657
+babel/locale-data/teo_UG.dat,sha256=0WlDglms5bCe1AMwCqroaXpOXu9jQroxllMwXWLb8q0,640
+babel/locale-data/tg.dat,sha256=ErMv0Y4SGno9gTSJbhMVKZXiSe_KNSUFaoBeIDaP8tk,117163
+babel/locale-data/tg_TJ.dat,sha256=TCrsEipGp0reAS2mAvwT58tyzBnYJfL5oNHWpEe1ttc,635
+babel/locale-data/th.dat,sha256=lyG_l3_QzfpnjCv8LVaRTvpvfImkVrqcDoUKrnXlIR4,215576
+babel/locale-data/th_TH.dat,sha256=_QhA0WcHmW6Cr_-gU9e6cdpzTMDT19WyHas58fWDUnc,635
+babel/locale-data/ti.dat,sha256=K4kS476YQonyQifjLpS4UkE7hNa2k5aIDBJRIdh2eDg,214273
+babel/locale-data/ti_ER.dat,sha256=m9w0P5TPQ8IqpWKldwdfnw5_1Upv09AjLdO5WUbcRic,962
+babel/locale-data/ti_ET.dat,sha256=q0b9svPg8aj9xmbXr7F6fPHqeTJmclBl5t_hqQk7IuU,635
+babel/locale-data/tig.dat,sha256=cgqxy3wiehP8yceqa5-mrJVT23IP_bjlkeUOEvxspUM,13481
+babel/locale-data/tig_ER.dat,sha256=OoQ0U6yyzmjKwDtzLUpqR09h_ZaGvzXlp7t-HqNxmm4,617
+babel/locale-data/tk.dat,sha256=z5i4kshTasDEolkNpqXnzlZh75EgbAhL0ylT0_0oioo,164932
+babel/locale-data/tk_TM.dat,sha256=lADxEQoz-_ImDBmpCFUqDPuZ0ozVUhZKOQF2ZwyXVlw,635
+babel/locale-data/tn.dat,sha256=LgoZgcUCS4t_RsyQQKiVsJ7Kbs7HoInZAMndRk6DUCM,8596
+babel/locale-data/tn_BW.dat,sha256=jWMFP1tw-o7rslHAlAIgjEXflko8UCDNaSuQ8ccvNHI,654
+babel/locale-data/tn_ZA.dat,sha256=S3dMOsYSpBwkUv0tW9q0kKawQQl6yx77LexAL5wQqDU,635
+babel/locale-data/to.dat,sha256=CBr6gRgu0qo_-kIoOluPwu_ZdH4-SPPJHto_ERcDzHA,145255
+babel/locale-data/to_TO.dat,sha256=jcfJ2Pjof8jGE4q1y5LHSP9rb4IanN58kR7OgG8d5Q0,616
+babel/locale-data/tok.dat,sha256=kuSPgVhnv8Rr55G-epQDVyh8FfeKxJbd2J0hierJdUQ,8870
+babel/locale-data/tok_001.dat,sha256=PPUMevT2TBOGFSq-U-AccYkLHSbkWnBRDvxtpokTCD4,693
+babel/locale-data/tpi.dat,sha256=mqTAJweAOy1SAH2l4mJAKktX-ZeAdvTC8JnBPxXjB0A,4030
+babel/locale-data/tpi_PG.dat,sha256=uZD_c8yCtiYwt2EO2VOYPzhSTqWMQBOJMCuMCXe3Css,617
+babel/locale-data/tr.dat,sha256=ULbjOvmQqcT1Z2_8bBOe7LzwgBUg3LWM2MiLkmb8M6w,150824
+babel/locale-data/tr_CY.dat,sha256=3EmCqxcPvFuZcHCzpTmHb6pjtPwqQvwCfn27B8rtXNw,1227
+babel/locale-data/tr_TR.dat,sha256=7lS5CMZw76SVlMJxsmIJW5IfL7k9t8MrfKcnElqISSI,635
+babel/locale-data/trv.dat,sha256=iEbFtCCE_U5rmjAv0Pe5J_UigixMKq1cPIThdZui1Lg,9404
+babel/locale-data/trv_TW.dat,sha256=CTQtGdDW4Z0n2Ckb6B63HgEwNE44YTFnJCetwd8q9GU,636
+babel/locale-data/trw.dat,sha256=1e1LGCtVq79RclEMJbgRE4ATdqflV_KDHxBwInSfAKc,110107
+babel/locale-data/trw_PK.dat,sha256=pBHdOulrwRLiQuC96g8ilUzpKBeG6kglBqUXB8MlURA,636
+babel/locale-data/ts.dat,sha256=p7EFPucK9HkTVXeNKTU00s-Oas5U_HCPGX9hqT15p9I,5522
+babel/locale-data/ts_ZA.dat,sha256=AByEO55W3DVVOBIBxIp1F2QwY01-5v6v8sDFOGSxCF0,635
+babel/locale-data/tt.dat,sha256=X-J0BKEHy01aoARwwb0SWDuNm1lZFrT0akKrzBZjHPM,111014
+babel/locale-data/tt_RU.dat,sha256=cmv2MzolKOrsRoqQcFZGcXQj_33dLWGh9oUjnebCnz0,653
+babel/locale-data/twq.dat,sha256=nOSN5UZAxcCgdTxQFh14Cyk5K38olCyAuT6MrVW5PeE,15509
+babel/locale-data/twq_NE.dat,sha256=y8xQDxMtyStWC83tm_JiekFxAY0Fj-CWWdmic9GBwd4,617
+babel/locale-data/tyv.dat,sha256=y90_CH7Yksd1Kuc6KhykhpkdGVLUgFDV-B4oSxGqn5E,693
+babel/locale-data/tyv_RU.dat,sha256=vP_6cjMLB8I8YL7Nqrq4Gu_AWGFuANbZSdBc7ORn_IA,654
+babel/locale-data/tzm.dat,sha256=wYFO2vX38bht1nAdcVA7dxKVMh-3yC5sItggFaXkKBo,15436
+babel/locale-data/tzm_MA.dat,sha256=8eku_7voAqAjN651VYKCuIWvdYGOScCyqbt1rtSVO_g,617
+babel/locale-data/ug.dat,sha256=jRJJxRRKuYljj6kYicIhxWk8ySzpMT9AOePaBk3EO94,117801
+babel/locale-data/ug_CN.dat,sha256=2UselU1_d6K7NgQj0EDnDfb4Llk51eQZ7z78oYE-Ywg,635
+babel/locale-data/uk.dat,sha256=b8iEhvLdQxq7rtlqpx1c9vp6-n3jNGPGSuBWNhZAnFA,339125
+babel/locale-data/uk_UA.dat,sha256=usJw_J4Uu9OD9nrUxNQAx6vMJBWDjbGuc9l7ssJAyuw,635
+babel/locale-data/ur.dat,sha256=RTL85URWDMA3albZQODUCbVTA9oxeYXo5kWtuL1XW6g,167002
+babel/locale-data/ur_IN.dat,sha256=9GV9YIa7Mftq14Po2C6fjMG5sWkU8J5LS5bq1iIcsHg,10550
+babel/locale-data/ur_PK.dat,sha256=EEAGl6fLd1-a7X0n2PwRxlqwYZ0a0ELm2DuLII9spX0,635
+babel/locale-data/uz.dat,sha256=iwj3ukxb4FK0rZYtC66ftQmTtr1SgTzy12Wu3KkQYQo,138052
+babel/locale-data/uz_Arab.dat,sha256=wt8BwimSNmoFzrnduGDXMHhqj3B8-XqqN6ghg2Xm74A,3814
+babel/locale-data/uz_Arab_AF.dat,sha256=68eUCR8KeB0QDQRCvNMiOIkZVRozGKFTDednrQL1X_Y,678
+babel/locale-data/uz_Cyrl.dat,sha256=RpmyW2YhTwN_o6sKyfJxcktFI6VMqkO6YDzDE8XoOTE,76581
+babel/locale-data/uz_Cyrl_UZ.dat,sha256=MWJtHPdj_pF2h6abRP4wUwDWAUF4-zr7jBn2RQcZ0z8,635
+babel/locale-data/uz_Latn.dat,sha256=L5H7Xfz2Ho-vMqviRPC4ai0MnqoF9CIebiq7muISvSA,1292
+babel/locale-data/uz_Latn_UZ.dat,sha256=MWJtHPdj_pF2h6abRP4wUwDWAUF4-zr7jBn2RQcZ0z8,635
+babel/locale-data/vai.dat,sha256=T_MWlDAfbp9qgeArFd8yPDPbyThU15kFu19QTQqAlCE,17416
+babel/locale-data/vai_Latn.dat,sha256=MecJYJumVm7wCyCo-YeAY4eAon5WZ4ZqR0shQ3Pdpu8,14255
+babel/locale-data/vai_Latn_LR.dat,sha256=LdVmBAL7nzDp-Ab_uHidBAi2crIf9nXhf8tBNfa7xdI,617
+babel/locale-data/vai_Vaii.dat,sha256=l_IXC76zzJ2lPLfWfjWzSw6xVtFwr-x8LofcHQsSG_0,693
+babel/locale-data/vai_Vaii_LR.dat,sha256=LdVmBAL7nzDp-Ab_uHidBAi2crIf9nXhf8tBNfa7xdI,617
+babel/locale-data/ve.dat,sha256=5bInQioXkePSDbBerQqf4sYPTiB9-zpKuDokCXX5eNA,2372
+babel/locale-data/ve_ZA.dat,sha256=uJndHi9RMKtDWd58f_Q3g5WgXjL3W7KLQj91rVueabQ,635
+babel/locale-data/vec.dat,sha256=zokLfsgTK7cSP4KaSV8EMpPlHiOkI6tG3rWM7o7vcAM,160413
+babel/locale-data/vec_IT.dat,sha256=mC9jRfk9ndmkpRIpWZNCwdMwvxvB6QX6_9HanawdaUw,654
+babel/locale-data/vi.dat,sha256=F95a-fvLPIeJqOlwx4gr9TnWZ0VpSPyzNwJ0RPc1qE8,134138
+babel/locale-data/vi_VN.dat,sha256=cGwN0vw-qIaeA2g89U97N1xHSMmmaIVNPCLL2P_QJMk,635
+babel/locale-data/vmw.dat,sha256=mhERiGM-732X9KO0CThGEyjFtSbquT1_rmzYPnru2SM,1796
+babel/locale-data/vmw_MZ.dat,sha256=sz0j5RufN9oAzTalcjWNhKtCoEXzeRr5Cv6qCouK45E,636
+babel/locale-data/vo.dat,sha256=werwY25uwomUcf9q1dyQ8Rwgg2aCoLp78XUzBeSw0LY,4609
+babel/locale-data/vo_001.dat,sha256=iF2xY9XIdxC0mOYEp9hjYZp2EG-si_YaNYXri_60-4w,850
+babel/locale-data/vun.dat,sha256=VGNPlnoRipnocGYPgeb39d9MmE6fe5nTMWtCk4m1AEY,15373
+babel/locale-data/vun_TZ.dat,sha256=YKrOeOS1VnU3BWQ7HWtxjS-gMKJcKAPQLf4HTgkzf70,617
+babel/locale-data/wa.dat,sha256=1r6krApI8oecIKQt_9RzbpwSN0LcWSjlG34Y9Rfh07Y,880
+babel/locale-data/wa_BE.dat,sha256=j4YADQloo07Oek1j3aOrLYkzcFkrViS1UdRrA0Z56-o,653
+babel/locale-data/wae.dat,sha256=qBKStFqpkAruVDgeZJvX6U0X-hq_NkETTqgR2e7A4UQ,29641
+babel/locale-data/wae_CH.dat,sha256=Z0Wzu5Q9IVTnLGwWu54ozVx-fgnFz0IE3yrky8Y1IkQ,654
+babel/locale-data/wal.dat,sha256=AD9ZfdNNjEhX2n9T0ykd_XwEbXK-wxmsLqq39O4BjWU,8406
+babel/locale-data/wal_ET.dat,sha256=tNjeuU4GPTWtDmsroGmi4VUql0dA57v1tEtDF4rslVg,636
+babel/locale-data/wbp.dat,sha256=kzXK04f538n-PrJl6nRKIaYHMid6rJ4ACmzPcCz7NgU,746
+babel/locale-data/wbp_AU.dat,sha256=BT2E1-WiomuRrteCzN1_AfLyDUdEOm0ehT5miAiepBQ,636
+babel/locale-data/wo.dat,sha256=iB86SoTMrnphiHy_om1Yxs-J8L5YFWYlbmiQjK6jc2k,61849
+babel/locale-data/wo_SN.dat,sha256=fvlwe-ImWs04fsxSjTsXf8IPxEIiEi45BX8xhoBC_yg,616
+babel/locale-data/xh.dat,sha256=xRy095MO_brgAUoDB3UKwhgDvOkBlhJ3cWj9dM2fvHI,64334
+babel/locale-data/xh_ZA.dat,sha256=9p6wHW1sxOghJMAgsP6BC3RdUhuvLpHoCkqvjsCmPps,635
+babel/locale-data/xnr.dat,sha256=Ot10zi4F4H5Yqx6kIJGPay65Rm-Gam2eJ7kAOgoJoJ0,142585
+babel/locale-data/xnr_IN.dat,sha256=UbNwudCNihEFVZu3ymanDhJ52YoupG0SDGwmDByPhzQ,659
+babel/locale-data/xog.dat,sha256=V4U36ibPCWDoUMf31-o9mDCwylsYU0nZEx5pt-MWecM,15866
+babel/locale-data/xog_UG.dat,sha256=bMX0Tk5zS4P2LqlOLLpVP4nZxBFhS_qc-ndXjilDCNI,640
+babel/locale-data/yav.dat,sha256=UupgFFmPVcV-IgY3Fd8Y9GoOcOWgY1P22ZHuA-4QSMU,14543
+babel/locale-data/yav_CM.dat,sha256=CsaKwep5CARetyBX-JXHFvUVsFe1KTN4Pyz1Wh7NTHw,636
+babel/locale-data/yi.dat,sha256=OWr2zb3k_toEmkSXcPweqE13Tr5RhvlMm4z358uCQiY,24264
+babel/locale-data/yi_UA.dat,sha256=DesjWHTuxEBrjOeq8c-B82j4Hnwu0ElR2IH3fZPmq-A,635
+babel/locale-data/yo.dat,sha256=iWLg-08Fk9QJLZPuokgbCeXkyfyQNaov51TT3i1pKgY,110427
+babel/locale-data/yo_BJ.dat,sha256=CuxWXwNyq_dWEw-rEwu3-4HAmZfZGwPkljOt0ttEWRc,50090
+babel/locale-data/yo_NG.dat,sha256=BEIndIiMT1Mo18S5DAWpjefthptCVQkIPeVs0umSop0,616
+babel/locale-data/yrl.dat,sha256=2nwDuw5Q_dL4H2Oxl5ClzZU2Uw10j-koP5RgfnJ67y0,186854
+babel/locale-data/yrl_BR.dat,sha256=aUgLCNwgEORk2wtuez8AqkYahB8_mX41IWSqogt39YE,636
+babel/locale-data/yrl_CO.dat,sha256=pT0rllDKHZAUIK_itrkWP7irmih4im131Ume_wKzyks,9211
+babel/locale-data/yrl_VE.dat,sha256=_Tqu_pGUkzrd4M9SKXpn4g93z7Q5xlUMAtGvROS5x6M,9211
+babel/locale-data/yue.dat,sha256=lvTaoHXSVZHqcb5UCR8IeDiVRCE9IRsrDkhv0bGwzCg,143872
+babel/locale-data/yue_Hans.dat,sha256=ybTM8LU-H-QunhqnLmCQ9bE6zdsYMJPHdlh_hBv3AWk,145194
+babel/locale-data/yue_Hans_CN.dat,sha256=MOZnu5r0xokf672rwAXfgzG3VEeTfNlDbu36fR1bB6I,636
+babel/locale-data/yue_Hant.dat,sha256=76wefuhsGIjk0jT05KSTEU_pbb7AfNE2u56jdRoJaDM,1306
+babel/locale-data/yue_Hant_CN.dat,sha256=l0nSr9oItZCMdphhuVjzHML7FpqAKZorutkLijFAwm4,1196
+babel/locale-data/yue_Hant_HK.dat,sha256=eMZ7mOTEyKzQz0MDIjvP_Z57CS9nFIP4-Uf0Jpx1CY4,636
+babel/locale-data/yue_Hant_MO.dat,sha256=d6oknkpchm3cIK_Ylk-PjHAaPKhtyg8cGFVBdqtIJBg,636
+babel/locale-data/za.dat,sha256=5EbAmE-qqvt_e4geaFxBGJi81CVoZFK4dCcJ346P4yU,12705
+babel/locale-data/za_CN.dat,sha256=WzhnaughSM1C1twuKYBVrelLEer-guzT43a9yBNXCsg,635
+babel/locale-data/zgh.dat,sha256=Q2D9KQFgDfWk4fXOdEbPcLq3yX_zxjhlK_PVI61Ok4U,22018
+babel/locale-data/zgh_MA.dat,sha256=sV8aPBmHY23lKIzsRna-tPz3UiXoKCMQ1Ur2tCyx2YA,617
+babel/locale-data/zh.dat,sha256=SpSkmdVN5PX7CCdso1B-SyQZKMDTyZfZeT2l_kj2FoI,152100
+babel/locale-data/zh_Hans.dat,sha256=-wR64b65stjA2KWj4GWcBWiF3yI0A24p4K7wApj8qtc,1305
+babel/locale-data/zh_Hans_CN.dat,sha256=zz2qPpWEP9ba12T9cGsPXGI7Bg5LcmZ3NkAMiVTf61A,635
+babel/locale-data/zh_Hans_HK.dat,sha256=yPyZyU-xXSNyU1FYJIYpWwnh0d3uXOra9V9aj2j_YQU,3621
+babel/locale-data/zh_Hans_MO.dat,sha256=08kUXwHOXA0pRA8qIX7e4p0Nzl1XHSBjwhMh7f-nZBE,3752
+babel/locale-data/zh_Hans_MY.dat,sha256=iEFxl2XEm1zBzd1K0wXpiZFvU7l0UrNURh2p9DZdRLU,1300
+babel/locale-data/zh_Hans_SG.dat,sha256=OHZNiUfnteSXuzel-lZAMVgv58iiVTNhjq81T9Qu94s,3948
+babel/locale-data/zh_Hant.dat,sha256=31aRGt18bl6MdiI9iAozwltdkSQQ370TvzI8gid8CBI,154802
+babel/locale-data/zh_Hant_HK.dat,sha256=NXPCE_4pYgLatoeKLdQ0d8PQ-Mk_GeMF1s1JYX9m27M,49152
+babel/locale-data/zh_Hant_MO.dat,sha256=qCWPPEr87U1aemaIuf6nCYQ-Q3w_1HcXrYoncYVBd3g,657
+babel/locale-data/zh_Hant_MY.dat,sha256=3n4syQpQ9sXVe82sOEH7yQIdrU3dAtMhp7fEhzGN8_E,1203
+babel/locale-data/zh_Hant_TW.dat,sha256=5N4K8I3XG89knCaSoy97HGzTVOTiUcd_VmfvNJlA4Bg,635
+babel/locale-data/zh_Latn.dat,sha256=-wR64b65stjA2KWj4GWcBWiF3yI0A24p4K7wApj8qtc,1305
+babel/locale-data/zh_Latn_CN.dat,sha256=zz2qPpWEP9ba12T9cGsPXGI7Bg5LcmZ3NkAMiVTf61A,635
+babel/locale-data/zu.dat,sha256=e48g3oI1FjkROV3yHZ2GAwn_8wr2y3dMkj98NHW4X8Q,138626
+babel/locale-data/zu_ZA.dat,sha256=jHloBfkNbQETXgE-3xVxvESitWb994_-SoY0G4_JL5E,635
+babel/localedata.py,sha256=94b-NvjmQuidIpptiz2NM-d_3615AxMnV8rQcaWalp0,9133
+babel/localtime/__init__.py,sha256=EuxZJNvscBH6gM6XKF3pBLWaeRTK3GdNB12WxG3jhaA,1019
+babel/localtime/__pycache__/__init__.cpython-310.pyc,,
+babel/localtime/__pycache__/_fallback.cpython-310.pyc,,
+babel/localtime/__pycache__/_helpers.cpython-310.pyc,,
+babel/localtime/__pycache__/_unix.cpython-310.pyc,,
+babel/localtime/__pycache__/_win32.cpython-310.pyc,,
+babel/localtime/_fallback.py,sha256=9h1CFwVX3laiA2oaZgAywRqEr0ghI4PuTCBKkFgbamI,1199
+babel/localtime/_helpers.py,sha256=ZmLc8m46W-3GtsstLBdrw6BU3ZhSob8vKHkxgcZG9uw,1704
+babel/localtime/_unix.py,sha256=22Xkddk98UiDP1LkDDjvxTL9J_5UXIFyDbxj_gD-gv8,3903
+babel/localtime/_win32.py,sha256=cjImlpejBFxzeP-BqTN2OOevboB06kZAlT_GMqQPqAc,3198
+babel/messages/__init__.py,sha256=Km-kd7AFHT231GjF16TlHdlWn7s3zQh1xA9SbKrxkWQ,329
+babel/messages/__pycache__/__init__.cpython-310.pyc,,
+babel/messages/__pycache__/_compat.cpython-310.pyc,,
+babel/messages/__pycache__/catalog.cpython-310.pyc,,
+babel/messages/__pycache__/checkers.cpython-310.pyc,,
+babel/messages/__pycache__/extract.cpython-310.pyc,,
+babel/messages/__pycache__/frontend.cpython-310.pyc,,
+babel/messages/__pycache__/jslexer.cpython-310.pyc,,
+babel/messages/__pycache__/mofile.cpython-310.pyc,,
+babel/messages/__pycache__/plurals.cpython-310.pyc,,
+babel/messages/__pycache__/pofile.cpython-310.pyc,,
+babel/messages/__pycache__/setuptools_frontend.cpython-310.pyc,,
+babel/messages/_compat.py,sha256=DNyCNMwH5vXgl_pq7cUYz3VcRC2gIPqeQLO5nN5neWE,1163
+babel/messages/catalog.py,sha256=7mtA4SWOcJAK_wJvONRKt1AgOKmTVq7PTI1tP73-Jk8,38647
+babel/messages/checkers.py,sha256=KX50Rceb6rYuCndDYeDijvRe2w1jg4l7RQd7NpaXRY0,6209
+babel/messages/extract.py,sha256=Ss2wc-uYicxaZ1szXE2SPpWRYx4BxD6wsR-L0VFPd-M,36875
+babel/messages/frontend.py,sha256=hwbxnZkfeFRriKKAC8NHbb6rHSQ4xOVcE9pbP0Qce3M,47518
+babel/messages/jslexer.py,sha256=_RRI0T-MDby3sBykA4fEM28qDSBwqdjfsFR2HW6GlsA,7262
+babel/messages/mofile.py,sha256=GgCmyPLbbChLVMsC6Wk3fiEunnru4u8N0gEvoUxYDr0,6907
+babel/messages/plurals.py,sha256=Azqltuu3uRrDh0TM-nckgaHlsYLC9-_qcDmWvcRCOwI,7489
+babel/messages/pofile.py,sha256=aNynbXhhulJizuJQUYKvjbV7ktwWqHLINCzK3MdxZYE,25437
+babel/messages/setuptools_frontend.py,sha256=m1l9NHuawj1pSncZeC82cUJfdwxib_C7JSUb_2EhbUM,3485
+babel/numbers.py,sha256=meEj4-Rp5B_WXd-lmHGunWwrw8PL_1oyc5IOPePnHiI,63469
+babel/plural.py,sha256=zU3sxaLb-jYTcimy-QOZSnDuLv0it-BxcT5H9E49mM0,23186
+babel/py.typed,sha256=DtCsIDq6KOv2NOEdQjTbeMWJKRh6ZEL2E-6Mf1RLeMA,59
+babel/support.py,sha256=oYq9nmEbvqpSwTLO69hOZ1TGb51okrEoyFN6M8NklfM,27906
+babel/units.py,sha256=0WsfuBXU150pPwbznrnt6Mc6vyrij2d9yTJj9MXnbGw,13982
+babel/util.py,sha256=-Zch-KLaAZgpC4jGGV8twKH8R8pCwd731ozEkUUI1qg,9395

micromamba_root/Lib/site-packages/babel-2.18.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

micromamba_root/Lib/site-packages/babel-2.18.0.dist-info/direct_url.json

@@ -0,0 +1 @@
+{"dir_info": {}, "url": "file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_babel_1772555330/work"}

micromamba_root/Lib/site-packages/babel-2.18.0.dist-info/entry_points.txt

@@ -0,0 +1,20 @@
+[babel.checkers]
+num_plurals = babel.messages.checkers:num_plurals
+python_format = babel.messages.checkers:python_format
+
+[babel.extractors]
+ignore = babel.messages.extract:extract_nothing
+javascript = babel.messages.extract:extract_javascript
+python = babel.messages.extract:extract_python
+
+[console_scripts]
+pybabel = babel.messages.frontend:main
+
+[distutils.commands]
+compile_catalog = babel.messages.setuptools_frontend:compile_catalog
+extract_messages = babel.messages.setuptools_frontend:extract_messages
+init_catalog = babel.messages.setuptools_frontend:init_catalog
+update_catalog = babel.messages.setuptools_frontend:update_catalog
+
+[distutils.setup_keywords]
+message_extractors = babel.messages.setuptools_frontend:check_message_extractors

micromamba_root/Lib/site-packages/babel-2.18.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+babel

micromamba_root/Lib/site-packages/babel/__init__.py

@@ -0,0 +1,38 @@
+"""
+babel
+~~~~~
+
+Integrated collection of utilities that assist in internationalizing and
+localizing applications.
+
+This package is basically composed of two major parts:
+
+ * tools to build and work with ``gettext`` message catalogs
+ * a Python interface to the CLDR (Common Locale Data Repository), providing
+   access to various locale display names, localized number and date
+   formatting, etc.
+
+:copyright: (c) 2013-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+from babel.core import (
+    Locale,
+    UnknownLocaleError,
+    default_locale,
+    get_locale_identifier,
+    negotiate_locale,
+    parse_locale,
+)
+
+__version__ = '2.18.0'
+
+__all__ = [
+    'Locale',
+    'UnknownLocaleError',
+    '__version__',
+    'default_locale',
+    'get_locale_identifier',
+    'negotiate_locale',
+    'parse_locale',
+]

micromamba_root/Lib/site-packages/babel/core.py

@@ -0,0 +1,1384 @@
+"""
+babel.core
+~~~~~~~~~~
+
+Core locale representation and locale data access.
+
+:copyright: (c) 2013-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+from collections.abc import Iterable, Mapping
+from typing import TYPE_CHECKING, Any, Literal
+
+from babel import localedata
+from babel.plural import PluralRule
+
+__all__ = [
+    'Locale',
+    'UnknownLocaleError',
+    'default_locale',
+    'get_cldr_version',
+    'get_global',
+    'get_locale_identifier',
+    'negotiate_locale',
+    'parse_locale',
+]
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    _GLOBAL_KEY: TypeAlias = Literal[
+        "all_currencies",
+        "cldr",
+        "currency_fractions",
+        "language_aliases",
+        "likely_subtags",
+        "meta_zones",
+        "parent_exceptions",
+        "script_aliases",
+        "territory_aliases",
+        "territory_currencies",
+        "territory_languages",
+        "territory_zones",
+        "variant_aliases",
+        "windows_zone_mapping",
+        "zone_aliases",
+        "zone_territories",
+    ]
+
+    _global_data: Mapping[_GLOBAL_KEY, Mapping[str, Any]] | None
+
+_global_data = None
+_default_plural_rule = PluralRule({})
+
+
+def _raise_no_data_error():
+    raise RuntimeError(
+        'The babel data files are not available. '
+        'This usually happens because you are using '
+        'a source checkout from Babel and you did '
+        'not build the data files.  Just make sure '
+        'to run "python setup.py import_cldr" before '
+        'installing the library.',
+    )
+
+
+def get_global(key: _GLOBAL_KEY) -> Mapping[str, Any]:
+    """Return the dictionary for the given key in the global data.
+
+    The global data is stored in the ``babel/global.dat`` file and contains
+    information independent of individual locales.
+
+    >>> get_global('zone_aliases')['UTC']
+    'Etc/UTC'
+    >>> get_global('zone_territories')['Europe/Berlin']
+    'DE'
+
+    The keys available are:
+
+    - ``all_currencies``
+    - ``cldr`` (metadata)
+    - ``currency_fractions``
+    - ``language_aliases``
+    - ``likely_subtags``
+    - ``parent_exceptions``
+    - ``script_aliases``
+    - ``territory_aliases``
+    - ``territory_currencies``
+    - ``territory_languages``
+    - ``territory_zones``
+    - ``variant_aliases``
+    - ``windows_zone_mapping``
+    - ``zone_aliases``
+    - ``zone_territories``
+
+    .. note:: The internal structure of the data may change between versions.
+
+    .. versionadded:: 0.9
+
+    :param key: the data key
+    """
+    global _global_data
+    if _global_data is None:
+        dirname = os.path.join(os.path.dirname(__file__))
+        filename = os.path.join(dirname, 'global.dat')
+        if not os.path.isfile(filename):
+            _raise_no_data_error()
+        with open(filename, 'rb') as fileobj:
+            _global_data = pickle.load(fileobj)
+            assert _global_data is not None
+    return _global_data.get(key, {})
+
+
+LOCALE_ALIASES = {
+    'ar': 'ar_SY', 'bg': 'bg_BG', 'bs': 'bs_BA', 'ca': 'ca_ES', 'cs': 'cs_CZ',
+    'da': 'da_DK', 'de': 'de_DE', 'el': 'el_GR', 'en': 'en_US', 'es': 'es_ES',
+    'et': 'et_EE', 'fa': 'fa_IR', 'fi': 'fi_FI', 'fr': 'fr_FR', 'gl': 'gl_ES',
+    'he': 'he_IL', 'hu': 'hu_HU', 'id': 'id_ID', 'is': 'is_IS', 'it': 'it_IT',
+    'ja': 'ja_JP', 'km': 'km_KH', 'ko': 'ko_KR', 'lt': 'lt_LT', 'lv': 'lv_LV',
+    'mk': 'mk_MK', 'nl': 'nl_NL', 'nn': 'nn_NO', 'no': 'nb_NO', 'pl': 'pl_PL',
+    'pt': 'pt_PT', 'ro': 'ro_RO', 'ru': 'ru_RU', 'sk': 'sk_SK', 'sl': 'sl_SI',
+    'sv': 'sv_SE', 'th': 'th_TH', 'tr': 'tr_TR', 'uk': 'uk_UA',
+}  # fmt: skip
+
+
+class UnknownLocaleError(Exception):
+    """Exception thrown when a locale is requested for which no locale data
+    is available.
+    """
+
+    def __init__(self, identifier: str) -> None:
+        """Create the exception.
+
+        :param identifier: the identifier string of the unsupported locale
+        """
+        Exception.__init__(self, f"unknown locale {identifier!r}")
+
+        #: The identifier of the locale that could not be found.
+        self.identifier = identifier
+
+
+class Locale:
+    """Representation of a specific locale.
+
+    >>> locale = Locale('en', 'US')
+    >>> repr(locale)
+    "Locale('en', territory='US')"
+    >>> locale.display_name
+    'English (United States)'
+
+    A `Locale` object can also be instantiated from a raw locale string:
+
+    >>> locale = Locale.parse('en-US', sep='-')
+    >>> repr(locale)
+    "Locale('en', territory='US')"
+
+    `Locale` objects provide access to a collection of locale data, such as
+    territory and language names, number and date format patterns, and more:
+
+    >>> locale.number_symbols['latn']['decimal']
+    '.'
+
+    If a locale is requested for which no locale data is available, an
+    `UnknownLocaleError` is raised:
+
+    >>> Locale.parse('en_XX')
+    Traceback (most recent call last):
+        ...
+    UnknownLocaleError: unknown locale 'en_XX'
+
+    For more information see :rfc:`3066`.
+    """
+
+    def __init__(
+        self,
+        language: str,
+        territory: str | None = None,
+        script: str | None = None,
+        variant: str | None = None,
+        modifier: str | None = None,
+    ) -> None:
+        """Initialize the locale object from the given identifier components.
+
+        >>> locale = Locale('en', 'US')
+        >>> locale.language
+        'en'
+        >>> locale.territory
+        'US'
+
+        :param language: the language code
+        :param territory: the territory (country or region) code
+        :param script: the script code
+        :param variant: the variant code
+        :param modifier: a modifier (following the '@' symbol, sometimes called '@variant')
+        :raise `UnknownLocaleError`: if no locale data is available for the
+                                     requested locale
+        """
+        #: the language code
+        self.language = language
+        #: the territory (country or region) code
+        self.territory = territory
+        #: the script code
+        self.script = script
+        #: the variant code
+        self.variant = variant
+        #: the modifier
+        self.modifier = modifier
+        self.__data: localedata.LocaleDataDict | None = None
+
+        identifier = str(self)
+        identifier_without_modifier = identifier.partition('@')[0]
+        if localedata.exists(identifier):
+            self.__data_identifier = identifier
+        elif localedata.exists(identifier_without_modifier):
+            self.__data_identifier = identifier_without_modifier
+        else:
+            raise UnknownLocaleError(identifier)
+
+    @classmethod
+    def default(
+        cls,
+        category: str | None = None,
+        aliases: Mapping[str, str] = LOCALE_ALIASES,
+    ) -> Locale:
+        """Return the system default locale for the specified category.
+
+        >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES']:
+        ...     os.environ[name] = ''
+        >>> os.environ['LANG'] = 'fr_FR.UTF-8'
+        >>> Locale.default('LC_MESSAGES')
+        Locale('fr', territory='FR')
+
+        The following fallbacks to the variable are always considered:
+
+        - ``LANGUAGE``
+        - ``LC_ALL``
+        - ``LC_CTYPE``
+        - ``LANG``
+
+        :param category: one of the ``LC_XXX`` environment variable names
+        :param aliases: a dictionary of aliases for locale identifiers
+        """
+        # XXX: use likely subtag expansion here instead of the
+        # aliases dictionary.
+        locale_string = default_locale(category, aliases=aliases)
+        return cls.parse(locale_string)
+
+    @classmethod
+    def negotiate(
+        cls,
+        preferred: Iterable[str],
+        available: Iterable[str],
+        sep: str = '_',
+        aliases: Mapping[str, str] = LOCALE_ALIASES,
+    ) -> Locale | None:
+        """Find the best match between available and requested locale strings.
+
+        >>> Locale.negotiate(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
+        Locale('de', territory='DE')
+        >>> Locale.negotiate(['de_DE', 'en_US'], ['en', 'de'])
+        Locale('de')
+        >>> Locale.negotiate(['de_DE', 'de'], ['en_US'])
+
+        You can specify the character used in the locale identifiers to separate
+        the different components. This separator is applied to both lists. Also,
+        case is ignored in the comparison:
+
+        >>> Locale.negotiate(['de-DE', 'de'], ['en-us', 'de-de'], sep='-')
+        Locale('de', territory='DE')
+
+        :param preferred: the list of locale identifiers preferred by the user
+        :param available: the list of locale identifiers available
+        :param aliases: a dictionary of aliases for locale identifiers
+        :param sep: separator for parsing; e.g. Windows tends to use '-' instead of '_'.
+        """
+        identifier = negotiate_locale(preferred, available, sep=sep, aliases=aliases)
+        if identifier:
+            return Locale.parse(identifier, sep=sep)
+        return None
+
+    @classmethod
+    def parse(
+        cls,
+        identifier: Locale | str | None,
+        sep: str = '_',
+        resolve_likely_subtags: bool = True,
+    ) -> Locale:
+        """Create a `Locale` instance for the given locale identifier.
+
+        >>> l = Locale.parse('de-DE', sep='-')
+        >>> l.display_name
+        'Deutsch (Deutschland)'
+
+        If the `identifier` parameter is not a string, but actually a `Locale`
+        object, that object is returned:
+
+        >>> Locale.parse(l)
+        Locale('de', territory='DE')
+
+        If the `identifier` parameter is neither of these, such as `None`
+        or an empty string, e.g. because a default locale identifier
+        could not be determined, a `TypeError` is raised:
+
+        >>> Locale.parse(None)
+        Traceback (most recent call last):
+            ...
+        TypeError: ...
+
+        This also can perform resolving of likely subtags which it does
+        by default.  This is for instance useful to figure out the most
+        likely locale for a territory you can use ``'und'`` as the
+        language tag:
+
+        >>> Locale.parse('und_AT')
+        Locale('de', territory='AT')
+
+        Modifiers are optional, and always at the end, separated by "@":
+
+        >>> Locale.parse('de_AT@euro')
+        Locale('de', territory='AT', modifier='euro')
+
+        :param identifier: the locale identifier string
+        :param sep: optional component separator
+        :param resolve_likely_subtags: if this is specified then a locale will
+                                       have its likely subtag resolved if the
+                                       locale otherwise does not exist.  For
+                                       instance ``zh_TW`` by itself is not a
+                                       locale that exists but Babel can
+                                       automatically expand it to the full
+                                       form of ``zh_hant_TW``.  Note that this
+                                       expansion is only taking place if no
+                                       locale exists otherwise.  For instance
+                                       there is a locale ``en`` that can exist
+                                       by itself.
+        :raise `ValueError`: if the string does not appear to be a valid locale
+                             identifier
+        :raise `UnknownLocaleError`: if no locale data is available for the
+                                     requested locale
+        :raise `TypeError`: if the identifier is not a string or a `Locale`
+        :raise `ValueError`: if the identifier is not a valid string
+        """
+        if isinstance(identifier, Locale):
+            return identifier
+
+        if not identifier:
+            msg = (
+                f"Empty locale identifier value: {identifier!r}\n\n"
+                f"If you didn't explicitly pass an empty value to a Babel function, "
+                f"this could be caused by there being no suitable locale environment "
+                f"variables for the API you tried to use."
+            )
+            if isinstance(identifier, str):
+                # `parse_locale` would raise a ValueError, so let's do that here
+                raise ValueError(msg)
+            raise TypeError(msg)
+
+        if not isinstance(identifier, str):
+            raise TypeError(f"Unexpected value for identifier: {identifier!r}")
+
+        parts = parse_locale(identifier, sep=sep)
+        input_id = get_locale_identifier(parts)
+
+        def _try_load(parts):
+            try:
+                return cls(*parts)
+            except UnknownLocaleError:
+                return None
+
+        def _try_load_reducing(parts):
+            # Success on first hit, return it.
+            locale = _try_load(parts)
+            if locale is not None:
+                return locale
+
+            # Now try without script and variant
+            locale = _try_load(parts[:2])
+            if locale is not None:
+                return locale
+
+        locale = _try_load(parts)
+        if locale is not None:
+            return locale
+        if not resolve_likely_subtags:
+            raise UnknownLocaleError(input_id)
+
+        # From here onwards is some very bad likely subtag resolving.  This
+        # whole logic is not entirely correct but good enough (tm) for the
+        # time being.  This has been added so that zh_TW does not cause
+        # errors for people when they upgrade.  Later we should properly
+        # implement ICU like fuzzy locale objects and provide a way to
+        # maximize and minimize locale tags.
+
+        if len(parts) == 5:
+            language, territory, script, variant, modifier = parts
+        else:
+            language, territory, script, variant = parts
+            modifier = None
+        language = get_global('language_aliases').get(language, language)
+        territory = get_global('territory_aliases').get(territory or '', (territory,))[0]
+        script = get_global('script_aliases').get(script or '', script)
+        variant = get_global('variant_aliases').get(variant or '', variant)
+
+        if territory == 'ZZ':
+            territory = None
+        if script == 'Zzzz':
+            script = None
+
+        parts = language, territory, script, variant, modifier
+
+        # First match: try the whole identifier
+        new_id = get_locale_identifier(parts)
+        likely_subtag = get_global('likely_subtags').get(new_id)
+        if likely_subtag is not None:
+            locale = _try_load_reducing(parse_locale(likely_subtag))
+            if locale is not None:
+                return locale
+
+        # If we did not find anything so far, try again with a
+        # simplified identifier that is just the language
+        likely_subtag = get_global('likely_subtags').get(language)
+        if likely_subtag is not None:
+            parts2 = parse_locale(likely_subtag)
+            if len(parts2) == 5:
+                language2, _, script2, variant2, modifier2 = parts2
+            else:
+                language2, _, script2, variant2 = parts2
+                modifier2 = None
+            locale = _try_load_reducing(
+                (language2, territory, script2, variant2, modifier2),
+            )
+            if locale is not None:
+                return locale
+
+        raise UnknownLocaleError(input_id)
+
+    def __eq__(self, other: object) -> bool:
+        for key in ('language', 'territory', 'script', 'variant', 'modifier'):
+            if not hasattr(other, key):
+                return False
+        return (
+            self.language == getattr(other, 'language')  # noqa: B009
+            and self.territory == getattr(other, 'territory')  # noqa: B009
+            and self.script == getattr(other, 'script')  # noqa: B009
+            and self.variant == getattr(other, 'variant')  # noqa: B009
+            and self.modifier == getattr(other, 'modifier')  # noqa: B009
+        )
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.language, self.territory, self.script, self.variant, self.modifier))
+
+    def __repr__(self) -> str:
+        parameters = ['']
+        for key in ('territory', 'script', 'variant', 'modifier'):
+            value = getattr(self, key)
+            if value is not None:
+                parameters.append(f"{key}={value!r}")
+        return f"Locale({self.language!r}{', '.join(parameters)})"
+
+    def __str__(self) -> str:
+        return get_locale_identifier(
+            (self.language, self.territory, self.script, self.variant, self.modifier),
+        )
+
+    @property
+    def _data(self) -> localedata.LocaleDataDict:
+        if self.__data is None:
+            self.__data = localedata.LocaleDataDict(localedata.load(self.__data_identifier))
+        return self.__data
+
+    def get_display_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the display name of the locale using the given locale.
+
+        The display name will include the language, territory, script, and
+        variant, if those are specified.
+
+        >>> Locale('zh', 'CN', script='Hans').get_display_name('en')
+        'Chinese (Simplified, China)'
+
+        Modifiers are currently passed through verbatim:
+
+        >>> Locale('it', 'IT', modifier='euro').get_display_name('en')
+        'Italian (Italy, euro)'
+
+        :param locale: the locale to use
+        """
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        retval = locale.languages.get(self.language)
+        if retval and (self.territory or self.script or self.variant):
+            details = []
+            if self.script:
+                details.append(locale.scripts.get(self.script))
+            if self.territory:
+                details.append(locale.territories.get(self.territory))
+            if self.variant:
+                details.append(locale.variants.get(self.variant))
+            if self.modifier:
+                details.append(self.modifier)
+            detail_string = ', '.join(atom for atom in details if atom)
+            if detail_string:
+                retval += f" ({detail_string})"
+        return retval
+
+    display_name = property(
+        get_display_name,
+        doc="""\
+        The localized display name of the locale.
+
+        >>> Locale('en').display_name
+        'English'
+        >>> Locale('en', 'US').display_name
+        'English (United States)'
+        >>> Locale('sv').display_name
+        'svenska'
+
+        :type: `unicode`
+        """,
+    )
+
+    def get_language_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the language of this locale in the given locale.
+
+        >>> Locale('zh', 'CN', script='Hans').get_language_name('de')
+        'Chinesisch'
+
+        .. versionadded:: 1.0
+
+        :param locale: the locale to use
+        """
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.languages.get(self.language)
+
+    language_name = property(
+        get_language_name,
+        doc="""\
+        The localized language name of the locale.
+
+        >>> Locale('en', 'US').language_name
+        'English'
+    """,
+    )
+
+    def get_territory_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the territory name in the given locale."""
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.territories.get(self.territory or '')
+
+    territory_name = property(
+        get_territory_name,
+        doc="""\
+        The localized territory name of the locale if available.
+
+        >>> Locale('de', 'DE').territory_name
+        'Deutschland'
+    """,
+    )
+
+    def get_script_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the script name in the given locale."""
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.scripts.get(self.script or '')
+
+    script_name = property(
+        get_script_name,
+        doc="""\
+        The localized script name of the locale if available.
+
+        >>> Locale('sr', 'ME', script='Latn').script_name
+        'latinica'
+    """,
+    )
+
+    @property
+    def english_name(self) -> str | None:
+        """The english display name of the locale.
+
+        >>> Locale('de').english_name
+        'German'
+        >>> Locale('de', 'DE').english_name
+        'German (Germany)'
+
+        :type: `unicode`"""
+        return self.get_display_name(Locale('en'))
+
+    # { General Locale Display Names
+
+    @property
+    def languages(self) -> localedata.LocaleDataDict:
+        """Mapping of language codes to translated language names.
+
+        >>> Locale('de', 'DE').languages['ja']
+        'Japanisch'
+
+        See `ISO 639 <https://www.loc.gov/standards/iso639-2/>`_ for
+        more information.
+        """
+        return self._data['languages']
+
+    @property
+    def scripts(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('en', 'US').scripts['Hira']
+        'Hiragana'
+
+        See `ISO 15924 <https://www.unicode.org/iso15924/>`_
+        for more information.
+        """
+        return self._data['scripts']
+
+    @property
+    def territories(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('es', 'CO').territories['DE']
+        'Alemania'
+
+        See `ISO 3166 <https://en.wikipedia.org/wiki/ISO_3166>`_
+        for more information.
+        """
+        return self._data['territories']
+
+    @property
+    def variants(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('de', 'DE').variants['1901']
+        'Alte deutsche Rechtschreibung'
+        """
+        return self._data['variants']
+
+    # { Number Formatting
+
+    @property
+    def currencies(self) -> localedata.LocaleDataDict:
+        """Mapping of currency codes to translated currency names.  This
+        only returns the generic form of the currency name, not the count
+        specific one.  If an actual number is requested use the
+        :func:`babel.numbers.get_currency_name` function.
+
+        >>> Locale('en').currencies['COP']
+        'Colombian Peso'
+        >>> Locale('de', 'DE').currencies['COP']
+        'Kolumbianischer Peso'
+        """
+        return self._data['currency_names']
+
+    @property
+    def currency_symbols(self) -> localedata.LocaleDataDict:
+        """Mapping of currency codes to symbols.
+
+        >>> Locale('en', 'US').currency_symbols['USD']
+        '$'
+        >>> Locale('es', 'CO').currency_symbols['USD']
+        'US$'
+        """
+        return self._data['currency_symbols']
+
+    @property
+    def number_symbols(self) -> localedata.LocaleDataDict:
+        """Symbols used in number formatting by number system.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('fr', 'FR').number_symbols["latn"]['decimal']
+        ','
+        >>> Locale('fa', 'IR').number_symbols["arabext"]['decimal']
+        '٫'
+        >>> Locale('fa', 'IR').number_symbols["latn"]['decimal']
+        '.'
+        """
+        return self._data['number_symbols']
+
+    @property
+    def other_numbering_systems(self) -> localedata.LocaleDataDict:
+        """
+        Mapping of other numbering systems available for the locale.
+        See: https://www.unicode.org/reports/tr35/tr35-numbers.html#otherNumberingSystems
+
+        >>> Locale('el', 'GR').other_numbering_systems['traditional']
+        'grek'
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+        """
+        return self._data['numbering_systems']
+
+    @property
+    def default_numbering_system(self) -> str:
+        """The default numbering system used by the locale.
+        >>> Locale('el', 'GR').default_numbering_system
+        'latn'
+        """
+        return self._data['default_numbering_system']
+
+    @property
+    def decimal_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for decimal number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').decimal_formats[None]
+        <NumberPattern '#,##0.###'>
+        """
+        return self._data['decimal_formats']
+
+    @property
+    def compact_decimal_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for compact decimal number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').compact_decimal_formats["short"]["one"]["1000"]
+        <NumberPattern '0K'>
+        """
+        return self._data['compact_decimal_formats']
+
+    @property
+    def currency_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for currency number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').currency_formats['standard']
+        <NumberPattern '\\xa4#,##0.00'>
+        >>> Locale('en', 'US').currency_formats['accounting']
+        <NumberPattern '\\xa4#,##0.00;(\\xa4#,##0.00)'>
+        """
+        return self._data['currency_formats']
+
+    @property
+    def compact_currency_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for compact currency number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').compact_currency_formats["short"]["one"]["1000"]
+        <NumberPattern '¤0K'>
+        """
+        return self._data['compact_currency_formats']
+
+    @property
+    def percent_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for percent number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').percent_formats[None]
+        <NumberPattern '#,##0%'>
+        """
+        return self._data['percent_formats']
+
+    @property
+    def scientific_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for scientific number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').scientific_formats[None]
+        <NumberPattern '#E0'>
+        """
+        return self._data['scientific_formats']
+
+    # { Calendar Information and Date Formatting
+
+    @property
+    def periods(self) -> localedata.LocaleDataDict:
+        """Locale display names for day periods (AM/PM).
+
+        >>> Locale('en', 'US').periods['am']
+        'AM'
+        """
+        try:
+            return self._data['day_periods']['stand-alone']['wide']
+        except KeyError:
+            return localedata.LocaleDataDict({})  # pragma: no cover
+
+    @property
+    def day_periods(self) -> localedata.LocaleDataDict:
+        """Locale display names for various day periods (not necessarily only AM/PM).
+
+        These are not meant to be used without the relevant `day_period_rules`.
+        """
+        return self._data['day_periods']
+
+    @property
+    def day_period_rules(self) -> localedata.LocaleDataDict:
+        """Day period rules for the locale.  Used by `get_period_id`."""
+        return self._data.get('day_period_rules', localedata.LocaleDataDict({}))
+
+    @property
+    def days(self) -> localedata.LocaleDataDict:
+        """Locale display names for weekdays.
+
+        >>> Locale('de', 'DE').days['format']['wide'][3]
+        'Donnerstag'
+        """
+        return self._data['days']
+
+    @property
+    def months(self) -> localedata.LocaleDataDict:
+        """Locale display names for months.
+
+        >>> Locale('de', 'DE').months['format']['wide'][10]
+        'Oktober'
+        """
+        return self._data['months']
+
+    @property
+    def quarters(self) -> localedata.LocaleDataDict:
+        """Locale display names for quarters.
+
+        >>> Locale('de', 'DE').quarters['format']['wide'][1]
+        '1. Quartal'
+        """
+        return self._data['quarters']
+
+    @property
+    def eras(self) -> localedata.LocaleDataDict:
+        """Locale display names for eras.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').eras['wide'][1]
+        'Anno Domini'
+        >>> Locale('en', 'US').eras['abbreviated'][0]
+        'BC'
+        """
+        return self._data['eras']
+
+    @property
+    def time_zones(self) -> localedata.LocaleDataDict:
+        """Locale display names for time zones.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').time_zones['Europe/London']['long']['daylight']
+        'British Summer Time'
+        >>> Locale('en', 'US').time_zones['America/St_Johns']['city']
+        'St. John’s'
+        """
+        return self._data['time_zones']
+
+    @property
+    def meta_zones(self) -> localedata.LocaleDataDict:
+        """Locale display names for meta time zones.
+
+        Meta time zones are basically groups of different Olson time zones that
+        have the same GMT offset and daylight savings time.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').meta_zones['Europe_Central']['long']['daylight']
+        'Central European Summer Time'
+
+        .. versionadded:: 0.9
+        """
+        return self._data['meta_zones']
+
+    @property
+    def zone_formats(self) -> localedata.LocaleDataDict:
+        """Patterns related to the formatting of time zones.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').zone_formats['fallback']
+        '%(1)s (%(0)s)'
+        >>> Locale('pt', 'BR').zone_formats['region']
+        'Horário %s'
+
+        .. versionadded:: 0.9
+        """
+        return self._data['zone_formats']
+
+    @property
+    def first_week_day(self) -> int:
+        """The first day of a week, with 0 being Monday.
+
+        >>> Locale('de', 'DE').first_week_day
+        0
+        >>> Locale('en', 'US').first_week_day
+        6
+        """
+        return self._data['week_data']['first_day']
+
+    @property
+    def weekend_start(self) -> int:
+        """The day the weekend starts, with 0 being Monday.
+
+        >>> Locale('de', 'DE').weekend_start
+        5
+        """
+        return self._data['week_data']['weekend_start']
+
+    @property
+    def weekend_end(self) -> int:
+        """The day the weekend ends, with 0 being Monday.
+
+        >>> Locale('de', 'DE').weekend_end
+        6
+        """
+        return self._data['week_data']['weekend_end']
+
+    @property
+    def min_week_days(self) -> int:
+        """The minimum number of days in a week so that the week is counted as
+        the first week of a year or month.
+
+        >>> Locale('de', 'DE').min_week_days
+        4
+        """
+        return self._data['week_data']['min_days']
+
+    @property
+    def date_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for date formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').date_formats['short']
+        <DateTimePattern 'M/d/yy'>
+        >>> Locale('fr', 'FR').date_formats['long']
+        <DateTimePattern 'd MMMM y'>
+        """
+        return self._data['date_formats']
+
+    @property
+    def time_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for time formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').time_formats['short']
+        <DateTimePattern 'h:mm\\u202fa'>
+        >>> Locale('fr', 'FR').time_formats['long']
+        <DateTimePattern 'HH:mm:ss z'>
+        """
+        return self._data['time_formats']
+
+    @property
+    def datetime_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for datetime formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en').datetime_formats['full']
+        '{1}, {0}'
+        >>> Locale('th').datetime_formats['medium']
+        '{1} {0}'
+        """
+        return self._data['datetime_formats']
+
+    @property
+    def datetime_skeletons(self) -> localedata.LocaleDataDict:
+        """Locale patterns for formatting parts of a datetime.
+
+        >>> Locale('en').datetime_skeletons['MEd']
+        <DateTimePattern 'E, M/d'>
+        >>> Locale('fr').datetime_skeletons['MEd']
+        <DateTimePattern 'E dd/MM'>
+        >>> Locale('fr').datetime_skeletons['H']
+        <DateTimePattern "HH 'h'">
+        """
+        return self._data['datetime_skeletons']
+
+    @property
+    def interval_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for interval formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        How to format date intervals in Finnish when the day is the
+        smallest changing component:
+
+        >>> Locale('fi_FI').interval_formats['MEd']['d']
+        ['E d.\\u2009–\\u2009', 'E d.M.']
+
+        .. seealso::
+
+           The primary API to use this data is :py:func:`babel.dates.format_interval`.
+
+
+        :rtype: dict[str, dict[str, list[str]]]
+        """
+        return self._data['interval_formats']
+
+    @property
+    def plural_form(self) -> PluralRule:
+        """Plural rules for the locale.
+
+        >>> Locale('en').plural_form(1)
+        'one'
+        >>> Locale('en').plural_form(0)
+        'other'
+        >>> Locale('fr').plural_form(0)
+        'one'
+        >>> Locale('ru').plural_form(100)
+        'many'
+        """
+        return self._data.get('plural_form', _default_plural_rule)
+
+    @property
+    def list_patterns(self) -> localedata.LocaleDataDict:
+        """Patterns for generating lists
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en').list_patterns['standard']['start']
+        '{0}, {1}'
+        >>> Locale('en').list_patterns['standard']['end']
+        '{0}, and {1}'
+        >>> Locale('en_GB').list_patterns['standard']['end']
+        '{0} and {1}'
+        """
+        return self._data['list_patterns']
+
+    @property
+    def ordinal_form(self) -> PluralRule:
+        """Plural rules for the locale.
+
+        >>> Locale('en').ordinal_form(1)
+        'one'
+        >>> Locale('en').ordinal_form(2)
+        'two'
+        >>> Locale('en').ordinal_form(3)
+        'few'
+        >>> Locale('fr').ordinal_form(2)
+        'other'
+        >>> Locale('ru').ordinal_form(100)
+        'other'
+        """
+        return self._data.get('ordinal_form', _default_plural_rule)
+
+    @property
+    def measurement_systems(self) -> localedata.LocaleDataDict:
+        """Localized names for various measurement systems.
+
+        >>> Locale('fr', 'FR').measurement_systems['US']
+        'américain'
+        >>> Locale('en', 'US').measurement_systems['US']
+        'US'
+
+        """
+        return self._data['measurement_systems']
+
+    @property
+    def character_order(self) -> str:
+        """The text direction for the language.
+
+        >>> Locale('de', 'DE').character_order
+        'left-to-right'
+        >>> Locale('ar', 'SA').character_order
+        'right-to-left'
+        """
+        return self._data['character_order']
+
+    @property
+    def text_direction(self) -> str:
+        """The text direction for the language in CSS short-hand form.
+
+        >>> Locale('de', 'DE').text_direction
+        'ltr'
+        >>> Locale('ar', 'SA').text_direction
+        'rtl'
+        """
+        return ''.join(word[0] for word in self.character_order.split('-'))
+
+    @property
+    def unit_display_names(self) -> localedata.LocaleDataDict:
+        """Display names for units of measurement.
+
+        .. seealso::
+
+           You may want to use :py:func:`babel.units.get_unit_name` instead.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        """
+        return self._data['unit_display_names']
+
+
+def default_locale(
+    category: str | tuple[str, ...] | list[str] | None = None,
+    aliases: Mapping[str, str] = LOCALE_ALIASES,
+) -> str | None:
+    """Returns the system default locale for a given category, based on
+    environment variables.
+
+    >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE']:
+    ...     os.environ[name] = ''
+    >>> os.environ['LANG'] = 'fr_FR.UTF-8'
+    >>> default_locale('LC_MESSAGES')
+    'fr_FR'
+
+    The "C" or "POSIX" pseudo-locales are treated as aliases for the
+    "en_US_POSIX" locale:
+
+    >>> os.environ['LC_MESSAGES'] = 'POSIX'
+    >>> default_locale('LC_MESSAGES')
+    'en_US_POSIX'
+
+    The following fallbacks to the variable are always considered:
+
+    - ``LANGUAGE``
+    - ``LC_ALL``
+    - ``LC_CTYPE``
+    - ``LANG``
+
+    :param category: one or more of the ``LC_XXX`` environment variable names
+    :param aliases: a dictionary of aliases for locale identifiers
+    """
+
+    varnames = ('LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LANG')
+    if category:
+        if isinstance(category, str):
+            varnames = (category, *varnames)
+        elif isinstance(category, (list, tuple)):
+            varnames = (*category, *varnames)
+        else:
+            raise TypeError(f"Invalid type for category: {category!r}")
+
+    for name in varnames:
+        if not name:
+            continue
+        locale = os.getenv(name)
+        if locale:
+            if name == 'LANGUAGE' and ':' in locale:
+                # the LANGUAGE variable may contain a colon-separated list of
+                # language codes; we just pick the language on the list
+                locale = locale.split(':')[0]
+            if locale.split('.')[0] in ('C', 'POSIX'):
+                locale = 'en_US_POSIX'
+            elif aliases and locale in aliases:
+                locale = aliases[locale]
+            try:
+                return get_locale_identifier(parse_locale(locale))
+            except ValueError:
+                pass
+    return None
+
+
+def negotiate_locale(
+    preferred: Iterable[str],
+    available: Iterable[str],
+    sep: str = '_',
+    aliases: Mapping[str, str] = LOCALE_ALIASES,
+) -> str | None:
+    """Find the best match between available and requested locale strings.
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
+    'de_DE'
+    >>> negotiate_locale(['de_DE', 'en_US'], ['en', 'de'])
+    'de'
+
+    Case is ignored by the algorithm, the result uses the case of the preferred
+    locale identifier:
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
+    'de_DE'
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
+    'de_DE'
+
+    By default, some web browsers unfortunately do not include the territory
+    in the locale identifier for many locales, and some don't even allow the
+    user to easily add the territory. So while you may prefer using qualified
+    locale identifiers in your web-application, they would not normally match
+    the language-only locale sent by such browsers. To workaround that, this
+    function uses a default mapping of commonly used language-only locale
+    identifiers to identifiers including the territory:
+
+    >>> negotiate_locale(['ja', 'en_US'], ['ja_JP', 'en_US'])
+    'ja_JP'
+
+    Some browsers even use an incorrect or outdated language code, such as "no"
+    for Norwegian, where the correct locale identifier would actually be "nb_NO"
+    (Bokmål) or "nn_NO" (Nynorsk). The aliases are intended to take care of
+    such cases, too:
+
+    >>> negotiate_locale(['no', 'sv'], ['nb_NO', 'sv_SE'])
+    'nb_NO'
+
+    You can override this default mapping by passing a different `aliases`
+    dictionary to this function, or you can bypass the behavior althogher by
+    setting the `aliases` parameter to `None`.
+
+    :param preferred: the list of locale strings preferred by the user
+    :param available: the list of locale strings available
+    :param sep: character that separates the different parts of the locale
+                strings
+    :param aliases: a dictionary of aliases for locale identifiers
+    """
+    available = [a.lower() for a in available if a]
+    for locale in preferred:
+        ll = locale.lower()
+        if ll in available:
+            return locale
+        if aliases:
+            alias = aliases.get(ll)
+            if alias:
+                alias = alias.replace('_', sep)
+                if alias.lower() in available:
+                    return alias
+        parts = locale.split(sep)
+        if len(parts) > 1 and parts[0].lower() in available:
+            return parts[0]
+    return None
+
+
+def parse_locale(
+    identifier: str,
+    sep: str = '_',
+) -> (
+    tuple[str, str | None, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None, str | None]
+):
+    """Parse a locale identifier into a tuple of the form ``(language,
+    territory, script, variant, modifier)``.
+
+    >>> parse_locale('zh_CN')
+    ('zh', 'CN', None, None)
+    >>> parse_locale('zh_Hans_CN')
+    ('zh', 'CN', 'Hans', None)
+    >>> parse_locale('ca_es_valencia')
+    ('ca', 'ES', None, 'VALENCIA')
+    >>> parse_locale('en_150')
+    ('en', '150', None, None)
+    >>> parse_locale('en_us_posix')
+    ('en', 'US', None, 'POSIX')
+    >>> parse_locale('it_IT@euro')
+    ('it', 'IT', None, None, 'euro')
+    >>> parse_locale('it_IT@custom')
+    ('it', 'IT', None, None, 'custom')
+    >>> parse_locale('it_IT@')
+    ('it', 'IT', None, None)
+
+    The default component separator is "_", but a different separator can be
+    specified using the `sep` parameter.
+
+    The optional modifier is always separated with "@" and at the end:
+
+    >>> parse_locale('zh-CN', sep='-')
+    ('zh', 'CN', None, None)
+    >>> parse_locale('zh-CN@custom', sep='-')
+    ('zh', 'CN', None, None, 'custom')
+
+    If the identifier cannot be parsed into a locale, a `ValueError` exception
+    is raised:
+
+    >>> parse_locale('not_a_LOCALE_String')
+    Traceback (most recent call last):
+      ...
+    ValueError: 'not_a_LOCALE_String' is not a valid locale identifier
+
+    Encoding information is removed from the identifier, while modifiers are
+    kept:
+
+    >>> parse_locale('en_US.UTF-8')
+    ('en', 'US', None, None)
+    >>> parse_locale('de_DE.iso885915@euro')
+    ('de', 'DE', None, None, 'euro')
+
+    See :rfc:`4646` for more information.
+
+    :param identifier: the locale identifier string
+    :param sep: character that separates the different components of the locale
+                identifier
+    :raise `ValueError`: if the string does not appear to be a valid locale
+                         identifier
+    """
+    if not identifier:
+        raise ValueError("empty locale identifier")
+    identifier, _, modifier = identifier.partition('@')
+    if '.' in identifier:
+        # this is probably the charset/encoding, which we don't care about
+        identifier = identifier.split('.', 1)[0]
+
+    parts = identifier.split(sep)
+    lang = parts.pop(0).lower()
+    if not lang.isalpha():
+        raise ValueError(f"expected only letters, got {lang!r}")
+
+    script = territory = variant = None
+    if parts and len(parts[0]) == 4 and parts[0].isalpha():
+        script = parts.pop(0).title()
+
+    if parts:
+        if len(parts[0]) == 2 and parts[0].isalpha():
+            territory = parts.pop(0).upper()
+        elif len(parts[0]) == 3 and parts[0].isdigit():
+            territory = parts.pop(0)
+
+    if parts and (
+        len(parts[0]) == 4
+        and parts[0][0].isdigit()
+        or len(parts[0]) >= 5
+        and parts[0][0].isalpha()
+    ):
+        variant = parts.pop().upper()
+
+    if parts:
+        raise ValueError(f"{identifier!r} is not a valid locale identifier")
+
+    # TODO(3.0): always return a 5-tuple
+    if modifier:
+        return lang, territory, script, variant, modifier
+    else:
+        return lang, territory, script, variant
+
+
+def get_locale_identifier(
+    tup: tuple[str]
+    | tuple[str, str | None]
+    | tuple[str, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None, str | None],
+    sep: str = "_",
+) -> str:
+    """The reverse of :func:`parse_locale`.  It creates a locale identifier out
+    of a ``(language, territory, script, variant, modifier)`` tuple.  Items can be set to
+    ``None`` and trailing ``None``\\s can also be left out of the tuple.
+
+    >>> get_locale_identifier(('de', 'DE', None, '1999', 'custom'))
+    'de_DE_1999@custom'
+    >>> get_locale_identifier(('fi', None, None, None, 'custom'))
+    'fi@custom'
+
+
+    .. versionadded:: 1.0
+
+    :param tup: the tuple as returned by :func:`parse_locale`.
+    :param sep: the separator for the identifier.
+    """
+    tup = tuple(tup[:5])  # type: ignore  # length should be no more than 5
+    lang, territory, script, variant, modifier = tup + (None,) * (5 - len(tup))
+    ret = sep.join(filter(None, (lang, script, territory, variant)))
+    return f'{ret}@{modifier}' if modifier else ret
+
+
+def get_cldr_version() -> str:
+    """Return the Unicode CLDR version used by this Babel installation.
+
+    Generally, you should be able to assume that the return value of this
+    function is a string representing a version number, e.g. '47'.
+
+    >>> get_cldr_version()
+    '47'
+
+    .. versionadded:: 2.18
+
+    :rtype: str
+    """
+    return str(get_global("cldr")["version"])

micromamba_root/Lib/site-packages/babel/dates.py

@@ -0,0 +1,2040 @@
+"""
+babel.dates
+~~~~~~~~~~~
+
+Locale dependent formatting and parsing of dates and times.
+
+The default locale for the functions in this module is determined by the
+following environment variables, in that order:
+
+ * ``LC_TIME``,
+ * ``LC_ALL``, and
+ * ``LANG``
+
+:copyright: (c) 2013-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+import warnings
+from functools import lru_cache
+from typing import TYPE_CHECKING, Literal, SupportsInt
+
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
+    import zoneinfo
+
+import datetime
+from collections.abc import Iterable
+
+from babel import localtime
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    _Instant: TypeAlias = datetime.date | datetime.time | float | None
+    _PredefinedTimeFormat: TypeAlias = Literal['full', 'long', 'medium', 'short']
+    _Context: TypeAlias = Literal['format', 'stand-alone']
+    _DtOrTzinfo: TypeAlias = datetime.datetime | datetime.tzinfo | str | int | datetime.time | None  # fmt: skip
+
+# "If a given short metazone form is known NOT to be understood in a given
+#  locale and the parent locale has this value such that it would normally
+#  be inherited, the inheritance of this value can be explicitly disabled by
+#  use of the 'no inheritance marker' as the value, which is 3 simultaneous [sic]
+#  empty set characters ( U+2205 )."
+#  - https://www.unicode.org/reports/tr35/tr35-dates.html#Metazone_Names
+
+NO_INHERITANCE_MARKER = '\u2205\u2205\u2205'
+
+UTC = datetime.timezone.utc
+LOCALTZ = localtime.LOCALTZ
+
+LC_TIME = default_locale('LC_TIME')
+
+
+def _localize(tz: datetime.tzinfo, dt: datetime.datetime) -> datetime.datetime:
+    # Support localizing with both pytz and zoneinfo tzinfos
+    # nothing to do
+    if dt.tzinfo is tz:
+        return dt
+
+    if hasattr(tz, 'localize'):  # pytz
+        return tz.localize(dt)
+
+    if dt.tzinfo is None:
+        # convert naive to localized
+        return dt.replace(tzinfo=tz)
+
+    # convert timezones
+    return dt.astimezone(tz)
+
+
+def _get_dt_and_tzinfo(
+    dt_or_tzinfo: _DtOrTzinfo,
+) -> tuple[datetime.datetime | None, datetime.tzinfo]:
+    """
+    Parse a `dt_or_tzinfo` value into a datetime and a tzinfo.
+
+    See the docs for this function's callers for semantics.
+
+    :rtype: tuple[datetime, tzinfo]
+    """
+    if dt_or_tzinfo is None:
+        dt = datetime.datetime.now()
+        tzinfo = LOCALTZ
+    elif isinstance(dt_or_tzinfo, str):
+        dt = None
+        tzinfo = get_timezone(dt_or_tzinfo)
+    elif isinstance(dt_or_tzinfo, int):
+        dt = None
+        tzinfo = UTC
+    elif isinstance(dt_or_tzinfo, (datetime.datetime, datetime.time)):
+        dt = _get_datetime(dt_or_tzinfo)
+        tzinfo = dt.tzinfo if dt.tzinfo is not None else UTC
+    else:
+        dt = None
+        tzinfo = dt_or_tzinfo
+    return dt, tzinfo
+
+
+def _get_tz_name(dt_or_tzinfo: _DtOrTzinfo) -> str:
+    """
+    Get the timezone name out of a time, datetime, or tzinfo object.
+
+    :rtype: str
+    """
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    if hasattr(tzinfo, 'zone'):  # pytz object
+        return tzinfo.zone
+    elif hasattr(tzinfo, 'key') and tzinfo.key is not None:  # ZoneInfo object
+        return tzinfo.key
+    else:
+        return tzinfo.tzname(dt or datetime.datetime.now(UTC))
+
+
+def _get_datetime(instant: _Instant) -> datetime.datetime:
+    """
+    Get a datetime out of an "instant" (date, time, datetime, number).
+
+    .. warning:: The return values of this function may depend on the system clock.
+
+    If the instant is None, the current moment is used.
+    If the instant is a time, it's augmented with today's date.
+
+    Dates are converted to naive datetimes with midnight as the time component.
+
+    >>> from datetime import date, datetime
+    >>> _get_datetime(date(2015, 1, 1))
+    datetime.datetime(2015, 1, 1, 0, 0)
+
+    UNIX timestamps are converted to datetimes.
+
+    >>> _get_datetime(1400000000)
+    datetime.datetime(2014, 5, 13, 16, 53, 20)
+
+    Other values are passed through as-is.
+
+    >>> x = datetime(2015, 1, 1)
+    >>> _get_datetime(x) is x
+    True
+
+    :param instant: date, time, datetime, integer, float or None
+    :type instant: date|time|datetime|int|float|None
+    :return: a datetime
+    :rtype: datetime
+    """
+    if instant is None:
+        return datetime.datetime.now(UTC).replace(tzinfo=None)
+    elif isinstance(instant, (int, float)):
+        return datetime.datetime.fromtimestamp(instant, UTC).replace(tzinfo=None)
+    elif isinstance(instant, datetime.time):
+        return datetime.datetime.combine(datetime.date.today(), instant)
+    elif isinstance(instant, datetime.date) and not isinstance(instant, datetime.datetime):  # fmt: skip
+        return datetime.datetime.combine(instant, datetime.time())
+    # TODO (3.x): Add an assertion/type check for this fallthrough branch:
+    return instant
+
+
+def _ensure_datetime_tzinfo(
+    dt: datetime.datetime,
+    tzinfo: datetime.tzinfo | None = None,
+) -> datetime.datetime:
+    """
+    Ensure the datetime passed has an attached tzinfo.
+
+    If the datetime is tz-naive to begin with, UTC is attached.
+
+    If a tzinfo is passed in, the datetime is normalized to that timezone.
+
+    >>> from datetime import datetime
+    >>> _get_tz_name(_ensure_datetime_tzinfo(datetime(2015, 1, 1)))
+    'UTC'
+
+    >>> tz = get_timezone("Europe/Stockholm")
+    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1, 13, 15, tzinfo=UTC), tzinfo=tz).hour
+    14
+
+    :param datetime: Datetime to augment.
+    :param tzinfo: optional tzinfo
+    :return: datetime with tzinfo
+    :rtype: datetime
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    if tzinfo is not None:
+        dt = dt.astimezone(get_timezone(tzinfo))
+        if hasattr(tzinfo, 'normalize'):  # pytz
+            dt = tzinfo.normalize(dt)
+    return dt
+
+
+def _get_time(
+    time: datetime.time | datetime.datetime | None,
+    tzinfo: datetime.tzinfo | None = None,
+) -> datetime.time:
+    """
+    Get a timezoned time from a given instant.
+
+    .. warning:: The return values of this function may depend on the system clock.
+
+    :param time: time, datetime or None
+    :rtype: time
+    """
+    if time is None:
+        time = datetime.datetime.now(UTC)
+    elif isinstance(time, (int, float)):
+        time = datetime.datetime.fromtimestamp(time, UTC)
+
+    if time.tzinfo is None:
+        time = time.replace(tzinfo=UTC)
+
+    if isinstance(time, datetime.datetime):
+        if tzinfo is not None:
+            time = time.astimezone(tzinfo)
+            if hasattr(tzinfo, 'normalize'):  # pytz
+                time = tzinfo.normalize(time)
+        time = time.timetz()
+    elif tzinfo is not None:
+        time = time.replace(tzinfo=tzinfo)
+    return time
+
+
+def get_timezone(zone: str | datetime.tzinfo | None = None) -> datetime.tzinfo:
+    """Looks up a timezone by name and returns it.  The timezone object
+    returned comes from ``pytz`` or ``zoneinfo``, whichever is available.
+    It corresponds to the `tzinfo` interface and can be used with all of
+    the functions of Babel that operate with dates.
+
+    If a timezone is not known a :exc:`LookupError` is raised.  If `zone`
+    is ``None`` a local zone object is returned.
+
+    :param zone: the name of the timezone to look up.  If a timezone object
+                 itself is passed in, it's returned unchanged.
+    """
+    if zone is None:
+        return LOCALTZ
+    if not isinstance(zone, str):
+        return zone
+
+    if pytz:
+        try:
+            return pytz.timezone(zone)
+        except pytz.UnknownTimeZoneError as e:
+            exc = e
+    else:
+        assert zoneinfo
+        try:
+            return zoneinfo.ZoneInfo(zone)
+        except zoneinfo.ZoneInfoNotFoundError as e:
+            exc = e
+
+    raise LookupError(f"Unknown timezone {zone}") from exc
+
+
+def get_period_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'stand-alone',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the names for day periods (AM/PM) used by the locale.
+
+    >>> get_period_names(locale='en_US')['am']
+    'AM'
+
+    :param width: the width to use, one of "abbreviated", "narrow", or "wide"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).day_periods[context][width]
+
+
+def get_day_names(
+    width: Literal['abbreviated', 'narrow', 'short', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the day names used by the locale for the specified format.
+
+    >>> get_day_names('wide', locale='en_US')[1]
+    'Tuesday'
+    >>> get_day_names('short', locale='en_US')[1]
+    'Tu'
+    >>> get_day_names('abbreviated', locale='es')[1]
+    'mar'
+    >>> get_day_names('narrow', context='stand-alone', locale='de_DE')[1]
+    'D'
+
+    :param width: the width to use, one of "wide", "abbreviated", "short" or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).days[context][width]
+
+
+def get_month_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the month names used by the locale for the specified format.
+
+    >>> get_month_names('wide', locale='en_US')[1]
+    'January'
+    >>> get_month_names('abbreviated', locale='es')[1]
+    'ene'
+    >>> get_month_names('narrow', context='stand-alone', locale='de_DE')[1]
+    'J'
+
+    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).months[context][width]
+
+
+def get_quarter_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    context: _Context = 'format',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the quarter names used by the locale for the specified format.
+
+    >>> get_quarter_names('wide', locale='en_US')[1]
+    '1st quarter'
+    >>> get_quarter_names('abbreviated', locale='de_DE')[1]
+    'Q1'
+    >>> get_quarter_names('narrow', locale='de_DE')[1]
+    '1'
+
+    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).quarters[context][width]
+
+
+def get_era_names(
+    width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+    locale: Locale | str | None = None,
+) -> LocaleDataDict:
+    """Return the era names used by the locale for the specified format.
+
+    >>> get_era_names('wide', locale='en_US')[1]
+    'Anno Domini'
+    >>> get_era_names('abbreviated', locale='de_DE')[1]
+    'n. Chr.'
+
+    :param width: the width to use, either "wide", "abbreviated", or "narrow"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).eras[width]
+
+
+def get_date_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the date formatting patterns used by the locale for the specified
+    format.
+
+    >>> get_date_format(locale='en_US')
+    <DateTimePattern 'MMM d, y'>
+    >>> get_date_format('full', locale='de_DE')
+    <DateTimePattern 'EEEE, d. MMMM y'>
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).date_formats[format]
+
+
+def get_datetime_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the datetime formatting patterns used by the locale for the
+    specified format.
+
+    >>> get_datetime_format(locale='en_US')
+    '{1}, {0}'
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    patterns = Locale.parse(locale or LC_TIME).datetime_formats
+    if format not in patterns:
+        format = None
+    return patterns[format]
+
+
+def get_time_format(
+    format: _PredefinedTimeFormat = 'medium',
+    locale: Locale | str | None = None,
+) -> DateTimePattern:
+    """Return the time formatting patterns used by the locale for the specified
+    format.
+
+    >>> get_time_format(locale='en_US')
+    <DateTimePattern 'h:mm:ss\\u202fa'>
+    >>> get_time_format('full', locale='de_DE')
+    <DateTimePattern 'HH:mm:ss zzzz'>
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    """
+    return Locale.parse(locale or LC_TIME).time_formats[format]
+
+
+def get_timezone_gmt(
+    datetime: _Instant = None,
+    width: Literal['long', 'short', 'iso8601', 'iso8601_short'] = 'long',
+    locale: Locale | str | None = None,
+    return_z: bool = False,
+) -> str:
+    """Return the timezone associated with the given `datetime` object formatted
+    as string indicating the offset from GMT.
+
+    >>> from datetime import datetime
+    >>> dt = datetime(2007, 4, 1, 15, 30)
+    >>> get_timezone_gmt(dt, locale='en')
+    'GMT+00:00'
+    >>> get_timezone_gmt(dt, locale='en', return_z=True)
+    'Z'
+    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
+    '+00'
+    >>> tz = get_timezone('America/Los_Angeles')
+    >>> dt = _localize(tz, datetime(2007, 4, 1, 15, 30))
+    >>> get_timezone_gmt(dt, locale='en')
+    'GMT-07:00'
+    >>> get_timezone_gmt(dt, 'short', locale='en')
+    '-0700'
+    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
+    '-07'
+
+    The long format depends on the locale, for example in France the acronym
+    UTC string is used instead of GMT:
+
+    >>> get_timezone_gmt(dt, 'long', locale='fr_FR')
+    'UTC-07:00'
+
+    .. versionadded:: 0.9
+
+    :param datetime: the ``datetime`` object; if `None`, the current date and
+                     time in UTC is used
+    :param width: either "long" or "short" or "iso8601" or "iso8601_short"
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_z: True or False; Function returns indicator "Z"
+                     when local time offset is 0
+    """
+    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime))
+    locale = Locale.parse(locale or LC_TIME)
+
+    offset = datetime.tzinfo.utcoffset(datetime)
+    seconds = offset.days * 24 * 60 * 60 + offset.seconds
+    hours, seconds = divmod(seconds, 3600)
+    if return_z and hours == 0 and seconds == 0:
+        return 'Z'
+    elif seconds == 0 and width == 'iso8601_short':
+        return '%+03d' % hours
+    elif width == 'short' or width == 'iso8601_short':
+        pattern = '%+03d%02d'
+    elif width == 'iso8601':
+        pattern = '%+03d:%02d'
+    else:
+        pattern = locale.zone_formats['gmt'] % '%+03d:%02d'
+    return pattern % (hours, seconds // 60)
+
+
+def get_timezone_location(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    locale: Locale | str | None = None,
+    return_city: bool = False,
+) -> str:
+    """Return a representation of the given timezone using "location format".
+
+    The result depends on both the local display name of the country and the
+    city associated with the time zone:
+
+    >>> tz = get_timezone('America/St_Johns')
+    >>> print(get_timezone_location(tz, locale='de_DE'))
+    Kanada (St. John’s) (Ortszeit)
+    >>> print(get_timezone_location(tz, locale='en'))
+    Canada (St. John’s) Time
+    >>> print(get_timezone_location(tz, locale='en', return_city=True))
+    St. John’s
+    >>> tz = get_timezone('America/Mexico_City')
+    >>> get_timezone_location(tz, locale='de_DE')
+    'Mexiko (Mexiko-Stadt) (Ortszeit)'
+
+    If the timezone is associated with a country that uses only a single
+    timezone, just the localized country name is returned:
+
+    >>> tz = get_timezone('Europe/Berlin')
+    >>> get_timezone_name(tz, locale='de_DE')
+    'Mitteleuropäische Zeit'
+
+    .. versionadded:: 0.9
+
+    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
+                         the timezone; if `None`, the current date and time in
+                         UTC is assumed
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_city: True or False, if True then return exemplar city (location)
+                        for the time zone
+    :return: the localized timezone name using location format
+
+    """
+    locale = Locale.parse(locale or LC_TIME)
+
+    zone = _get_tz_name(dt_or_tzinfo)
+
+    # Get the canonical time-zone code
+    zone = get_global('zone_aliases').get(zone, zone)
+
+    info = locale.time_zones.get(zone, {})
+
+    # Otherwise, if there is only one timezone for the country, return the
+    # localized country name
+    region_format = locale.zone_formats['region']
+    territory = get_global('zone_territories').get(zone)
+    if territory not in locale.territories:
+        territory = 'ZZ'  # invalid/unknown
+    territory_name = locale.territories[territory]
+    if (
+        not return_city
+        and territory
+        and len(get_global('territory_zones').get(territory, [])) == 1
+    ):
+        return region_format % territory_name
+
+    # Otherwise, include the city in the output
+    fallback_format = locale.zone_formats['fallback']
+    if 'city' in info:
+        city_name = info['city']
+    else:
+        metazone = get_global('meta_zones').get(zone)
+        metazone_info = locale.meta_zones.get(metazone, {})
+        if 'city' in metazone_info:
+            city_name = metazone_info['city']
+        elif '/' in zone:
+            city_name = zone.split('/', 1)[1].replace('_', ' ')
+        else:
+            city_name = zone.replace('_', ' ')
+
+    if return_city:
+        return city_name
+    return region_format % (
+        fallback_format
+        % {
+            '0': city_name,
+            '1': territory_name,
+        }
+    )
+
+
+def get_timezone_name(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    width: Literal['long', 'short'] = 'long',
+    uncommon: bool = False,
+    locale: Locale | str | None = None,
+    zone_variant: Literal['generic', 'daylight', 'standard'] | None = None,
+    return_zone: bool = False,
+) -> str:
+    r"""Return the localized display name for the given timezone. The timezone
+    may be specified using a ``datetime`` or `tzinfo` object.
+
+    >>> from datetime import time
+    >>> dt = time(15, 30, tzinfo=get_timezone('America/Los_Angeles'))
+    >>> get_timezone_name(dt, locale='en_US')  # doctest: +SKIP
+    'Pacific Standard Time'
+    >>> get_timezone_name(dt, locale='en_US', return_zone=True)
+    'America/Los_Angeles'
+    >>> get_timezone_name(dt, width='short', locale='en_US')  # doctest: +SKIP
+    'PST'
+
+    If this function gets passed only a `tzinfo` object and no concrete
+    `datetime`,  the returned display name is independent of daylight savings
+    time. This can be used for example for selecting timezones, or to set the
+    time of events that recur across DST changes:
+
+    >>> tz = get_timezone('America/Los_Angeles')
+    >>> get_timezone_name(tz, locale='en_US')
+    'Pacific Time'
+    >>> get_timezone_name(tz, 'short', locale='en_US')
+    'PT'
+
+    If no localized display name for the timezone is available, and the timezone
+    is associated with a country that uses only a single timezone, the name of
+    that country is returned, formatted according to the locale:
+
+    >>> tz = get_timezone('Europe/Berlin')
+    >>> get_timezone_name(tz, locale='de_DE')
+    'Mitteleuropäische Zeit'
+    >>> get_timezone_name(tz, locale='pt_BR')
+    'Horário da Europa Central'
+
+    On the other hand, if the country uses multiple timezones, the city is also
+    included in the representation:
+
+    >>> tz = get_timezone('America/St_Johns')
+    >>> get_timezone_name(tz, locale='de_DE')
+    'Neufundland-Zeit'
+
+    Note that short format is currently not supported for all timezones and
+    all locales.  This is partially because not every timezone has a short
+    code in every locale.  In that case it currently falls back to the long
+    format.
+
+    For more information see `LDML Appendix J: Time Zone Display Names
+    <https://www.unicode.org/reports/tr35/#Time_Zone_Fallback>`_
+
+    .. versionadded:: 0.9
+
+    .. versionchanged:: 1.0
+       Added `zone_variant` support.
+
+    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
+                         the timezone; if a ``tzinfo`` object is used, the
+                         resulting display name will be generic, i.e.
+                         independent of daylight savings time; if `None`, the
+                         current date in UTC is assumed
+    :param width: either "long" or "short"
+    :param uncommon: deprecated and ignored
+    :param zone_variant: defines the zone variation to return.  By default the
+                           variation is defined from the datetime object
+                           passed in.  If no datetime object is passed in, the
+                           ``'generic'`` variation is assumed.  The following
+                           values are valid: ``'generic'``, ``'daylight'`` and
+                           ``'standard'``.
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :param return_zone: True or False. If true then function
+                        returns long time zone ID
+    """
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    locale = Locale.parse(locale or LC_TIME)
+
+    zone = _get_tz_name(dt_or_tzinfo)
+
+    if zone_variant is None:
+        if dt is None:
+            zone_variant = 'generic'
+        else:
+            dst = tzinfo.dst(dt)
+            zone_variant = "daylight" if dst else "standard"
+    else:
+        if zone_variant not in ('generic', 'standard', 'daylight'):
+            raise ValueError('Invalid zone variation')
+
+    # Get the canonical time-zone code
+    zone = get_global('zone_aliases').get(zone, zone)
+    if return_zone:
+        return zone
+    info = locale.time_zones.get(zone, {})
+    # Try explicitly translated zone names first
+    if width in info and zone_variant in info[width]:
+        value = info[width][zone_variant]
+        if value != NO_INHERITANCE_MARKER:
+            return value
+
+    metazone = get_global('meta_zones').get(zone)
+    if metazone:
+        metazone_info = locale.meta_zones.get(metazone, {})
+        if width in metazone_info:
+            name = metazone_info[width].get(zone_variant)
+            if width == 'short' and name == NO_INHERITANCE_MARKER:
+                # If the short form is marked no-inheritance,
+                # try to fall back to the long name instead.
+                name = metazone_info.get('long', {}).get(zone_variant)
+            if name and name != NO_INHERITANCE_MARKER:
+                return name
+
+    # If we have a concrete datetime, we assume that the result can't be
+    # independent of daylight savings time, so we return the GMT offset
+    if dt is not None:
+        return get_timezone_gmt(dt, width=width, locale=locale)
+
+    return get_timezone_location(dt_or_tzinfo, locale=locale)
+
+
+def format_date(
+    date: datetime.date | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    locale: Locale | str | None = None,
+) -> str:
+    """Return a date formatted according to the given pattern.
+
+    >>> from datetime import date
+    >>> d = date(2007, 4, 1)
+    >>> format_date(d, locale='en_US')
+    'Apr 1, 2007'
+    >>> format_date(d, format='full', locale='de_DE')
+    'Sonntag, 1. April 2007'
+
+    If you don't want to use the locale default formats, you can specify a
+    custom date pattern:
+
+    >>> format_date(d, "EEE, MMM d, ''yy", locale='en')
+    "Sun, Apr 1, '07"
+
+    :param date: the ``date`` or ``datetime`` object; if `None`, the current
+                 date is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    if date is None:
+        date = datetime.date.today()
+    elif isinstance(date, datetime.datetime):
+        date = date.date()
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        format = get_date_format(format, locale=locale)
+    pattern = parse_pattern(format)
+    return pattern.apply(date, locale)
+
+
+def format_datetime(
+    datetime: _Instant = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a date formatted according to the given pattern.
+
+    >>> from datetime import datetime
+    >>> dt = datetime(2007, 4, 1, 15, 30)
+    >>> format_datetime(dt, locale='en_US')
+    'Apr 1, 2007, 3:30:00\u202fPM'
+
+    For any pattern requiring the display of the timezone:
+
+    >>> format_datetime(dt, 'full', tzinfo=get_timezone('Europe/Paris'),
+    ...                 locale='fr_FR')
+    'dimanche 1 avril 2007, 17:30:00 heure d’été d’Europe centrale'
+    >>> format_datetime(dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
+    ...                 tzinfo=get_timezone('US/Eastern'), locale='en')
+    '2007.04.01 AD at 11:30:00 EDT'
+
+    :param datetime: the `datetime` object; if `None`, the current date and
+                     time is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param tzinfo: the timezone to apply to the time for display
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime), tzinfo)
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        return (
+            get_datetime_format(format, locale=locale)
+            .replace("'", "")
+            .replace('{0}', format_time(datetime, format, tzinfo=None, locale=locale))
+            .replace('{1}', format_date(datetime, format, locale=locale))
+        )
+    else:
+        return parse_pattern(format).apply(datetime, locale)
+
+
+def format_time(
+    time: datetime.time | datetime.datetime | float | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a time formatted according to the given pattern.
+
+    >>> from datetime import datetime, time
+    >>> t = time(15, 30)
+    >>> format_time(t, locale='en_US')
+    '3:30:00\u202fPM'
+    >>> format_time(t, format='short', locale='de_DE')
+    '15:30'
+
+    If you don't want to use the locale default formats, you can specify a
+    custom time pattern:
+
+    >>> format_time(t, "hh 'o''clock' a", locale='en')
+    "03 o'clock PM"
+
+    For any pattern requiring the display of the time-zone a
+    timezone has to be specified explicitly:
+
+    >>> t = datetime(2007, 4, 1, 15, 30)
+    >>> tzinfo = get_timezone('Europe/Paris')
+    >>> t = _localize(tzinfo, t)
+    >>> format_time(t, format='full', tzinfo=tzinfo, locale='fr_FR')
+    '15:30:00 heure d’été d’Europe centrale'
+    >>> format_time(t, "hh 'o''clock' a, zzzz", tzinfo=get_timezone('US/Eastern'),
+    ...             locale='en')
+    "09 o'clock AM, Eastern Daylight Time"
+
+    As that example shows, when this function gets passed a
+    ``datetime.datetime`` value, the actual time in the formatted string is
+    adjusted to the timezone specified by the `tzinfo` parameter. If the
+    ``datetime`` is "naive" (i.e. it has no associated timezone information),
+    it is assumed to be in UTC.
+
+    These timezone calculations are **not** performed if the value is of type
+    ``datetime.time``, as without date information there's no way to determine
+    what a given time would translate to in a different timezone without
+    information about whether daylight savings time is in effect or not. This
+    means that time values are left as-is, and the value of the `tzinfo`
+    parameter is only used to display the timezone name if needed:
+
+    >>> t = time(15, 30)
+    >>> format_time(t, format='full', tzinfo=get_timezone('Europe/Paris'),
+    ...             locale='fr_FR')  # doctest: +SKIP
+    '15:30:00 heure normale d\u2019Europe centrale'
+    >>> format_time(t, format='full', tzinfo=get_timezone('US/Eastern'),
+    ...             locale='en_US')  # doctest: +SKIP
+    '3:30:00\u202fPM Eastern Standard Time'
+
+    :param time: the ``time`` or ``datetime`` object; if `None`, the current
+                 time in UTC is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param tzinfo: the time-zone to apply to the time for display
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+
+    # get reference date for if we need to find the right timezone variant
+    # in the pattern
+    ref_date = time.date() if isinstance(time, datetime.datetime) else None
+
+    time = _get_time(time, tzinfo)
+
+    locale = Locale.parse(locale or LC_TIME)
+    if format in ('full', 'long', 'medium', 'short'):
+        format = get_time_format(format, locale=locale)
+    return parse_pattern(format).apply(time, locale, reference_date=ref_date)
+
+
+def format_skeleton(
+    skeleton: str,
+    datetime: _Instant = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = None,
+) -> str:
+    r"""Return a time and/or date formatted according to the given pattern.
+
+    The skeletons are defined in the CLDR data and provide more flexibility
+    than the simple short/long/medium formats, but are a bit harder to use.
+    The are defined using the date/time symbols without order or punctuation
+    and map to a suitable format for the given locale.
+
+    >>> from datetime import datetime
+    >>> t = datetime(2007, 4, 1, 15, 30)
+    >>> format_skeleton('MMMEd', t, locale='fr')
+    'dim. 1 avr.'
+    >>> format_skeleton('MMMEd', t, locale='en')
+    'Sun, Apr 1'
+    >>> format_skeleton('yMMd', t, locale='fi')  # yMMd is not in the Finnish locale; yMd gets used
+    '1.4.2007'
+    >>> format_skeleton('yMMd', t, fuzzy=False, locale='fi')  # yMMd is not in the Finnish locale, an error is thrown
+    Traceback (most recent call last):
+        ...
+    KeyError: yMMd
+    >>> format_skeleton('GH', t, fuzzy=True, locale='fi_FI')  # GH is not in the Finnish locale and there is no close match, an error is thrown
+    Traceback (most recent call last):
+        ...
+    KeyError: None
+
+    After the skeleton is resolved to a pattern `format_datetime` is called so
+    all timezone processing etc is the same as for that.
+
+    :param skeleton: A date time skeleton as defined in the cldr data.
+    :param datetime: the ``time`` or ``datetime`` object; if `None`, the current
+                 time in UTC is used
+    :param tzinfo: the time-zone to apply to the time for display
+    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
+                  close enough to it. If there is no close match, a `KeyError`
+                  is thrown.
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    locale = Locale.parse(locale or LC_TIME)
+    if fuzzy and skeleton not in locale.datetime_skeletons:
+        skeleton = match_skeleton(skeleton, locale.datetime_skeletons)
+    format = locale.datetime_skeletons[skeleton]
+    return format_datetime(datetime, format, tzinfo, locale)
+
+
+TIMEDELTA_UNITS: tuple[tuple[str, int], ...] = (
+    ('year', 3600 * 24 * 365),
+    ('month', 3600 * 24 * 30),
+    ('week', 3600 * 24 * 7),
+    ('day', 3600 * 24),
+    ('hour', 3600),
+    ('minute', 60),
+    ('second', 1),
+)
+
+
+def format_timedelta(
+    delta: datetime.timedelta | int,
+    granularity: Literal[
+        'year',
+        'month',
+        'week',
+        'day',
+        'hour',
+        'minute',
+        'second',
+    ] = 'second',
+    threshold: float = 0.85,
+    add_direction: bool = False,
+    format: Literal['narrow', 'short', 'medium', 'long'] = 'long',
+    locale: Locale | str | None = None,
+) -> str:
+    """Return a time delta according to the rules of the given locale.
+
+    >>> from datetime import timedelta
+    >>> format_timedelta(timedelta(weeks=12), locale='en_US')
+    '3 months'
+    >>> format_timedelta(timedelta(seconds=1), locale='es')
+    '1 segundo'
+
+    The granularity parameter can be provided to alter the lowest unit
+    presented, which defaults to a second.
+
+    >>> format_timedelta(timedelta(hours=3), granularity='day', locale='en_US')
+    '1 day'
+
+    The threshold parameter can be used to determine at which value the
+    presentation switches to the next higher unit. A higher threshold factor
+    means the presentation will switch later. For example:
+
+    >>> format_timedelta(timedelta(hours=23), threshold=0.9, locale='en_US')
+    '1 day'
+    >>> format_timedelta(timedelta(hours=23), threshold=1.1, locale='en_US')
+    '23 hours'
+
+    In addition directional information can be provided that informs
+    the user if the date is in the past or in the future:
+
+    >>> format_timedelta(timedelta(hours=1), add_direction=True, locale='en')
+    'in 1 hour'
+    >>> format_timedelta(timedelta(hours=-1), add_direction=True, locale='en')
+    '1 hour ago'
+
+    The format parameter controls how compact or wide the presentation is:
+
+    >>> format_timedelta(timedelta(hours=3), format='short', locale='en')
+    '3 hr'
+    >>> format_timedelta(timedelta(hours=3), format='narrow', locale='en')
+    '3h'
+
+    :param delta: a ``timedelta`` object representing the time difference to
+                  format, or the delta in seconds as an `int` value
+    :param granularity: determines the smallest unit that should be displayed,
+                        the value can be one of "year", "month", "week", "day",
+                        "hour", "minute" or "second"
+    :param threshold: factor that determines at which point the presentation
+                      switches to the next higher unit
+    :param add_direction: if this flag is set to `True` the return value will
+                          include directional information.  For instance a
+                          positive timedelta will include the information about
+                          it being in the future, a negative will be information
+                          about the value being in the past.
+    :param format: the format, can be "narrow", "short" or "long". (
+                   "medium" is deprecated, currently converted to "long" to
+                   maintain compatibility)
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    """
+    if format not in ('narrow', 'short', 'medium', 'long'):
+        raise TypeError('Format must be one of "narrow", "short" or "long"')
+    if format == 'medium':
+        warnings.warn(
+            '"medium" value for format param of format_timedelta is deprecated. Use "long" instead',
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        format = 'long'
+    if isinstance(delta, datetime.timedelta):
+        seconds = int((delta.days * 86400) + delta.seconds)
+    else:
+        seconds = delta
+    locale = Locale.parse(locale or LC_TIME)
+    date_fields = locale._data["date_fields"]
+    unit_patterns = locale._data["unit_patterns"]
+
+    def _iter_patterns(a_unit):
+        if add_direction:
+            # Try to find the length variant version first ("year-narrow")
+            # before falling back to the default.
+            unit_rel_patterns = date_fields.get(f"{a_unit}-{format}") or date_fields[a_unit]
+            if seconds >= 0:
+                yield unit_rel_patterns['future']
+            else:
+                yield unit_rel_patterns['past']
+        a_unit = f"duration-{a_unit}"
+        unit_pats = unit_patterns.get(a_unit, {})
+        yield unit_pats.get(format)
+        # We do not support `<alias>` tags at all while ingesting CLDR data,
+        # so these aliases specified in `root.xml` are hard-coded here:
+        # <unitLength type="long"><alias source="locale" path="../unitLength[@type='short']"/></unitLength>
+        # <unitLength type="narrow"><alias source="locale" path="../unitLength[@type='short']"/></unitLength>
+        if format in ("long", "narrow"):
+            yield unit_pats.get("short")
+
+    for unit, secs_per_unit in TIMEDELTA_UNITS:
+        value = abs(seconds) / secs_per_unit
+        if value >= threshold or unit == granularity:
+            if unit == granularity and value > 0:
+                value = max(1, value)
+            value = int(round(value))
+            plural_form = locale.plural_form(value)
+            pattern = None
+            for patterns in _iter_patterns(unit):
+                if patterns is not None:
+                    pattern = patterns.get(plural_form) or patterns.get('other')
+                    if pattern:
+                        break
+            # This really should not happen
+            if pattern is None:
+                return ''
+            return pattern.replace('{0}', str(value))
+
+    return ''
+
+
+def _format_fallback_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None,
+    tzinfo: datetime.tzinfo | None,
+    locale: Locale,
+) -> str:
+    if skeleton in locale.datetime_skeletons:  # Use the given skeleton
+        format = lambda dt: format_skeleton(skeleton, dt, tzinfo, locale=locale)
+    elif all(
+        # Both are just dates
+        (isinstance(d, datetime.date) and not isinstance(d, datetime.datetime))
+        for d in (start, end)
+    ):
+        format = lambda dt: format_date(dt, locale=locale)
+    elif all(
+        # Both are times
+        (isinstance(d, datetime.time) and not isinstance(d, datetime.date))
+        for d in (start, end)
+    ):
+        format = lambda dt: format_time(dt, tzinfo=tzinfo, locale=locale)
+    else:
+        format = lambda dt: format_datetime(dt, tzinfo=tzinfo, locale=locale)
+
+    formatted_start = format(start)
+    formatted_end = format(end)
+
+    if formatted_start == formatted_end:
+        return format(start)
+
+    return (
+        locale.interval_formats.get(None, "{0}-{1}")
+        .replace("{0}", formatted_start)
+        .replace("{1}", formatted_end)
+    )
+
+
+def format_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Format an interval between two instants according to the locale's rules.
+
+    >>> from datetime import date, time
+    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "yMd", locale="fi")
+    '15.–17.1.2016'
+
+    >>> format_interval(time(12, 12), time(16, 16), "Hm", locale="en_GB")
+    '12:12–16:16'
+
+    >>> format_interval(time(5, 12), time(16, 16), "hm", locale="en_US")
+    '5:12\\u202fAM\\u2009–\\u20094:16\\u202fPM'
+
+    >>> format_interval(time(16, 18), time(16, 24), "Hm", locale="it")
+    '16:18–16:24'
+
+    If the start instant equals the end instant, the interval is formatted like the instant.
+
+    >>> format_interval(time(16, 18), time(16, 18), "Hm", locale="it")
+    '16:18'
+
+    Unknown skeletons fall back to "default" formatting.
+
+    >>> format_interval(date(2015, 1, 1), date(2017, 1, 1), "wzq", locale="ja")
+    '2015/01/01～2017/01/01'
+
+    >>> format_interval(time(16, 18), time(16, 24), "xxx", locale="ja")
+    '16:18:00～16:24:00'
+
+    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "xxx", locale="de")
+    '15.01.2016\\u2009–\\u200917.01.2016'
+
+    :param start: First instant (datetime/date/time)
+    :param end: Second instant (datetime/date/time)
+    :param skeleton: The "skeleton format" to use for formatting.
+    :param tzinfo: tzinfo to use (if none is already attached)
+    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
+                  close enough to it.
+    :param locale: A locale object or identifier. Defaults to the system time locale.
+    :return: Formatted interval
+    """
+    locale = Locale.parse(locale or LC_TIME)
+
+    # NB: The quote comments below are from the algorithm description in
+    #     https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
+
+    # > Look for the intervalFormatItem element that matches the "skeleton",
+    # > starting in the current locale and then following the locale fallback
+    # > chain up to, but not including root.
+
+    interval_formats = locale.interval_formats
+
+    if skeleton not in interval_formats or not skeleton:
+        # > If no match was found from the previous step, check what the closest
+        # > match is in the fallback locale chain, as in availableFormats. That
+        # > is, this allows for adjusting the string value field's width,
+        # > including adjusting between "MMM" and "MMMM", and using different
+        # > variants of the same field, such as 'v' and 'z'.
+        if skeleton and fuzzy:
+            skeleton = match_skeleton(skeleton, interval_formats)
+        else:
+            skeleton = None
+        if not skeleton:  # Still no match whatsoever?
+            # > Otherwise, format the start and end datetime using the fallback pattern.
+            return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
+
+    skel_formats = interval_formats[skeleton]
+
+    if start == end:
+        return format_skeleton(skeleton, start, tzinfo, fuzzy=fuzzy, locale=locale)
+
+    start = _ensure_datetime_tzinfo(_get_datetime(start), tzinfo=tzinfo)
+    end = _ensure_datetime_tzinfo(_get_datetime(end), tzinfo=tzinfo)
+
+    start_fmt = DateTimeFormat(start, locale=locale)
+    end_fmt = DateTimeFormat(end, locale=locale)
+
+    # > If a match is found from previous steps, compute the calendar field
+    # > with the greatest difference between start and end datetime. If there
+    # > is no difference among any of the fields in the pattern, format as a
+    # > single date using availableFormats, and return.
+
+    for field in PATTERN_CHAR_ORDER:  # These are in largest-to-smallest order
+        if field in skel_formats and start_fmt.extract(field) != end_fmt.extract(field):
+            # > If there is a match, use the pieces of the corresponding pattern to
+            # > format the start and end datetime, as above.
+            return "".join(
+                parse_pattern(pattern).apply(instant, locale)
+                for pattern, instant in zip(skel_formats[field], (start, end))
+            )
+
+    # > Otherwise, format the start and end datetime using the fallback pattern.
+
+    return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
+
+
+def get_period_id(
+    time: _Instant,
+    tzinfo: datetime.tzinfo | None = None,
+    type: Literal['selection'] | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Get the day period ID for a given time.
+
+    This ID can be used as a key for the period name dictionary.
+
+    >>> from datetime import time
+    >>> get_period_names(locale="de")[get_period_id(time(7, 42), locale="de")]
+    'Morgen'
+
+    >>> get_period_id(time(0), locale="en_US")
+    'midnight'
+
+    >>> get_period_id(time(0), type="selection", locale="en_US")
+    'morning1'
+
+    :param time: The time to inspect.
+    :param tzinfo: The timezone for the time. See ``format_time``.
+    :param type: The period type to use. Either "selection" or None.
+                 The selection type is used for selecting among phrases such as
+                 “Your email arrived yesterday evening” or “Your email arrived last night”.
+    :param locale: the `Locale` object, or a locale string. Defaults to the system time locale.
+    :return: period ID. Something is always returned -- even if it's just "am" or "pm".
+    """
+    time = _get_time(time, tzinfo)
+    seconds_past_midnight = int(time.hour * 60 * 60 + time.minute * 60 + time.second)
+    locale = Locale.parse(locale or LC_TIME)
+
+    # The LDML rules state that the rules may not overlap, so iterating in arbitrary
+    # order should be alright, though `at` periods should be preferred.
+    rulesets = locale.day_period_rules.get(type, {}).items()
+
+    for rule_id, rules in rulesets:
+        for rule in rules:
+            if "at" in rule and rule["at"] == seconds_past_midnight:
+                return rule_id
+
+    for rule_id, rules in rulesets:
+        for rule in rules:
+            if "from" in rule and "before" in rule:
+                if rule["from"] < rule["before"]:
+                    if rule["from"] <= seconds_past_midnight < rule["before"]:
+                        return rule_id
+                else:
+                    # e.g. from="21:00" before="06:00"
+                    if (
+                        rule["from"] <= seconds_past_midnight < 86400
+                        or 0 <= seconds_past_midnight < rule["before"]
+                    ):
+                        return rule_id
+
+            start_ok = end_ok = False
+
+            if "from" in rule and seconds_past_midnight >= rule["from"]:
+                start_ok = True
+            if "to" in rule and seconds_past_midnight <= rule["to"]:
+                # This rule type does not exist in the present CLDR data;
+                # excuse the lack of test coverage.
+                end_ok = True
+            if "before" in rule and seconds_past_midnight < rule["before"]:
+                end_ok = True
+            if "after" in rule:
+                raise NotImplementedError("'after' is deprecated as of CLDR 29.")
+
+            if start_ok and end_ok:
+                return rule_id
+
+    if seconds_past_midnight < 43200:
+        return "am"
+    else:
+        return "pm"
+
+
+class ParseError(ValueError):
+    pass
+
+
+def parse_date(
+    string: str,
+    locale: Locale | str | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+) -> datetime.date:
+    """Parse a date from a string.
+
+    If an explicit format is provided, it is used to parse the date.
+
+    >>> parse_date('01.04.2004', format='dd.MM.yyyy')
+    datetime.date(2004, 4, 1)
+
+    If no format is given, or if it is one of "full", "long", "medium",
+    or "short", the function first tries to interpret the string as
+    ISO-8601 date format and then uses the date format for the locale
+    as a hint to determine the order in which the date fields appear in
+    the string.
+
+    >>> parse_date('4/1/04', locale='en_US')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('01.04.2004', locale='de_DE')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('2004-04-01', locale='en_US')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('2004-04-01', locale='de_DE')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('01.04.04', locale='de_DE', format='short')
+    datetime.date(2004, 4, 1)
+
+    :param string: the string containing the date
+    :param locale: a `Locale` object or a locale identifier
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    :param format: the format to use, either an explicit date format,
+                   or one of "full", "long", "medium", or "short"
+                   (see ``get_time_format``)
+    """
+    numbers = re.findall(r'(\d+)', string)
+    if not numbers:
+        raise ParseError("No numbers were found in input")
+
+    use_predefined_format = format in ('full', 'long', 'medium', 'short')
+    # we try ISO-8601 format first, meaning similar to formats
+    # extended YYYY-MM-DD or basic YYYYMMDD
+    iso_alike = re.match(
+        r'^(\d{4})-?([01]\d)-?([0-3]\d)$',
+        string,
+        flags=re.ASCII,  # allow only ASCII digits
+    )
+    if iso_alike and use_predefined_format:
+        try:
+            return datetime.date(*map(int, iso_alike.groups()))
+        except ValueError:
+            pass  # a locale format might fit better, so let's continue
+
+    if use_predefined_format:
+        fmt = get_date_format(format=format, locale=locale)
+    else:
+        fmt = parse_pattern(format)
+    format_str = fmt.pattern.lower()
+    year_idx = format_str.index('y')
+    month_idx = format_str.find('m')
+    if month_idx < 0:
+        month_idx = format_str.index('l')
+    day_idx = format_str.index('d')
+
+    indexes = sorted([(year_idx, 'Y'), (month_idx, 'M'), (day_idx, 'D')])
+    indexes = {item[1]: idx for idx, item in enumerate(indexes)}
+
+    # FIXME: this currently only supports numbers, but should also support month
+    #        names, both in the requested locale, and english
+
+    year = numbers[indexes['Y']]
+    year = 2000 + int(year) if len(year) == 2 else int(year)
+    month = int(numbers[indexes['M']])
+    day = int(numbers[indexes['D']])
+    if month > 12:
+        month, day = day, month
+    return datetime.date(year, month, day)
+
+
+def parse_time(
+    string: str,
+    locale: Locale | str | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+) -> datetime.time:
+    """Parse a time from a string.
+
+    This function uses the time format for the locale as a hint to determine
+    the order in which the time fields appear in the string.
+
+    If an explicit format is provided, the function will use it to parse
+    the time instead.
+
+    >>> parse_time('15:30:00', locale='en_US')
+    datetime.time(15, 30)
+    >>> parse_time('15:30:00', format='H:mm:ss')
+    datetime.time(15, 30)
+
+    :param string: the string containing the time
+    :param locale: a `Locale` object or a locale identifier. Defaults to the system time locale.
+    :param format: the format to use, either an explicit time format,
+                   or one of "full", "long", "medium", or "short"
+                   (see ``get_time_format``)
+    :return: the parsed time
+    :rtype: `time`
+    """
+    numbers = re.findall(r'(\d+)', string)
+    if not numbers:
+        raise ParseError("No numbers were found in input")
+
+    # TODO: try ISO format first?
+    if format in ('full', 'long', 'medium', 'short'):
+        fmt = get_time_format(format=format, locale=locale)
+    else:
+        fmt = parse_pattern(format)
+    format_str = fmt.pattern.lower()
+    hour_idx = format_str.find('h')
+    if hour_idx < 0:
+        hour_idx = format_str.index('k')
+    min_idx = format_str.index('m')
+    # format might not contain seconds
+    if (sec_idx := format_str.find('s')) < 0:
+        sec_idx = math.inf
+
+    indexes = sorted([(hour_idx, 'H'), (min_idx, 'M'), (sec_idx, 'S')])
+    indexes = {item[1]: idx for idx, item in enumerate(indexes)}
+
+    # TODO: support time zones
+
+    # Check if the format specifies a period to be used;
+    # if it does, look for 'pm' to figure out an offset.
+    hour_offset = 0
+    if 'a' in format_str and 'pm' in string.lower():
+        hour_offset = 12
+
+    # Parse up to three numbers from the string.
+    minute = second = 0
+    hour = int(numbers[indexes['H']]) + hour_offset
+    if len(numbers) > 1:
+        minute = int(numbers[indexes['M']])
+        if len(numbers) > 2:
+            second = int(numbers[indexes['S']])
+    return datetime.time(hour, minute, second)
+
+
+class DateTimePattern:
+    def __init__(self, pattern: str, format: DateTimeFormat):
+        self.pattern = pattern
+        self.format = format
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.pattern!r}>"
+
+    def __str__(self) -> str:
+        pat = self.pattern
+        return pat
+
+    def __mod__(self, other: DateTimeFormat) -> str:
+        if not isinstance(other, DateTimeFormat):
+            return NotImplemented
+        return self.format % other
+
+    def apply(
+        self,
+        datetime: datetime.date | datetime.time,
+        locale: Locale | str | None,
+        reference_date: datetime.date | None = None,
+    ) -> str:
+        return self % DateTimeFormat(datetime, locale, reference_date)
+
+
+class DateTimeFormat:
+    def __init__(
+        self,
+        value: datetime.date | datetime.time,
+        locale: Locale | str,
+        reference_date: datetime.date | None = None,
+    ) -> None:
+        assert isinstance(value, (datetime.date, datetime.datetime, datetime.time))
+        if isinstance(value, (datetime.datetime, datetime.time)) and value.tzinfo is None:
+            value = value.replace(tzinfo=UTC)
+        self.value = value
+        self.locale = Locale.parse(locale)
+        self.reference_date = reference_date
+
+    def __getitem__(self, name: str) -> str:
+        char = name[0]
+        num = len(name)
+        if char == 'G':
+            return self.format_era(char, num)
+        elif char in ('y', 'Y', 'u'):
+            return self.format_year(char, num)
+        elif char in ('Q', 'q'):
+            return self.format_quarter(char, num)
+        elif char in ('M', 'L'):
+            return self.format_month(char, num)
+        elif char in ('w', 'W'):
+            return self.format_week(char, num)
+        elif char == 'd':
+            return self.format(self.value.day, num)
+        elif char == 'D':
+            return self.format_day_of_year(num)
+        elif char == 'F':
+            return self.format_day_of_week_in_month()
+        elif char in ('E', 'e', 'c'):
+            return self.format_weekday(char, num)
+        elif char in ('a', 'b', 'B'):
+            return self.format_period(char, num)
+        elif char == 'h':
+            if self.value.hour % 12 == 0:
+                return self.format(12, num)
+            else:
+                return self.format(self.value.hour % 12, num)
+        elif char == 'H':
+            return self.format(self.value.hour, num)
+        elif char == 'K':
+            return self.format(self.value.hour % 12, num)
+        elif char == 'k':
+            if self.value.hour == 0:
+                return self.format(24, num)
+            else:
+                return self.format(self.value.hour, num)
+        elif char == 'm':
+            return self.format(self.value.minute, num)
+        elif char == 's':
+            return self.format(self.value.second, num)
+        elif char == 'S':
+            return self.format_frac_seconds(num)
+        elif char == 'A':
+            return self.format_milliseconds_in_day(num)
+        elif char in ('z', 'Z', 'v', 'V', 'x', 'X', 'O'):
+            return self.format_timezone(char, num)
+        else:
+            raise KeyError(f"Unsupported date/time field {char!r}")
+
+    def extract(self, char: str) -> int:
+        char = str(char)[0]
+        if char == 'y':
+            return self.value.year
+        elif char == 'M':
+            return self.value.month
+        elif char == 'd':
+            return self.value.day
+        elif char == 'H':
+            return self.value.hour
+        elif char == 'h':
+            return self.value.hour % 12 or 12
+        elif char == 'm':
+            return self.value.minute
+        elif char == 'a':
+            return int(self.value.hour >= 12)  # 0 for am, 1 for pm
+        else:
+            raise NotImplementedError(
+                f"Not implemented: extracting {char!r} from {self.value!r}",
+            )
+
+    def format_era(self, char: str, num: int) -> str:
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)]
+        era = int(self.value.year >= 0)
+        return get_era_names(width, self.locale)[era]
+
+    def format_year(self, char: str, num: int) -> str:
+        value = self.value.year
+        if char.isupper():
+            month = self.value.month
+            if month == 1 and self.value.day < 7 and self.get_week_of_year() >= 52:
+                value -= 1
+            elif month == 12 and self.value.day > 25 and self.get_week_of_year() <= 2:
+                value += 1
+        year = self.format(value, num)
+        if num == 2:
+            year = year[-2:]
+        return year
+
+    def format_quarter(self, char: str, num: int) -> str:
+        quarter = (self.value.month - 1) // 3 + 1
+        if num <= 2:
+            return '%0*d' % (num, quarter)
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
+        context = {'Q': 'format', 'q': 'stand-alone'}[char]
+        return get_quarter_names(width, context, self.locale)[quarter]
+
+    def format_month(self, char: str, num: int) -> str:
+        if num <= 2:
+            return '%0*d' % (num, self.value.month)
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
+        context = {'M': 'format', 'L': 'stand-alone'}[char]
+        return get_month_names(width, context, self.locale)[self.value.month]
+
+    def format_week(self, char: str, num: int) -> str:
+        if char.islower():  # week of year
+            week = self.get_week_of_year()
+            return self.format(week, num)
+        else:  # week of month
+            week = self.get_week_of_month()
+            return str(week)
+
+    def format_weekday(self, char: str = 'E', num: int = 4) -> str:
+        """
+        Return weekday from parsed datetime according to format pattern.
+
+        >>> from datetime import date
+        >>> format = DateTimeFormat(date(2016, 2, 28), Locale.parse('en_US'))
+        >>> format.format_weekday()
+        'Sunday'
+
+        'E': Day of week - Use one through three letters for the abbreviated day name, four for the full (wide) name,
+             five for the narrow name, or six for the short name.
+        >>> format.format_weekday('E',2)
+        'Sun'
+
+        'e': Local day of week. Same as E except adds a numeric value that will depend on the local starting day of the
+             week, using one or two letters. For this example, Monday is the first day of the week.
+        >>> format.format_weekday('e',2)
+        '01'
+
+        'c': Stand-Alone local day of week - Use one letter for the local numeric value (same as 'e'), three for the
+             abbreviated day name, four for the full (wide) name, five for the narrow name, or six for the short name.
+        >>> format.format_weekday('c',1)
+        '1'
+
+        :param char: pattern format character ('e','E','c')
+        :param num: count of format character
+
+        """
+        if num < 3:
+            if char.islower():
+                value = 7 - self.locale.first_week_day + self.value.weekday()
+                return self.format(value % 7 + 1, num)
+            num = 3
+        weekday = self.value.weekday()
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow', 6: 'short'}[num]
+        context = "stand-alone" if char == "c" else "format"
+        return get_day_names(width, context, self.locale)[weekday]
+
+    def format_day_of_year(self, num: int) -> str:
+        return self.format(self.get_day_of_year(), num)
+
+    def format_day_of_week_in_month(self) -> str:
+        return str((self.value.day - 1) // 7 + 1)
+
+    def format_period(self, char: str, num: int) -> str:
+        """
+        Return period from parsed datetime according to format pattern.
+
+        >>> from datetime import datetime, time
+        >>> format = DateTimeFormat(time(13, 42), 'fi_FI')
+        >>> format.format_period('a', 1)
+        'ip.'
+        >>> format.format_period('b', 1)
+        'iltap.'
+        >>> format.format_period('b', 4)
+        'iltapäivä'
+        >>> format.format_period('B', 4)
+        'iltapäivällä'
+        >>> format.format_period('B', 5)
+        'ip.'
+
+        >>> format = DateTimeFormat(datetime(2022, 4, 28, 6, 27), 'zh_Hant')
+        >>> format.format_period('a', 1)
+        '上午'
+        >>> format.format_period('B', 1)
+        '清晨'
+
+        :param char: pattern format character ('a', 'b', 'B')
+        :param num: count of format character
+
+        """
+        widths = [
+            {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)],
+            'wide',
+            'narrow',
+            'abbreviated',
+        ]
+        if char == 'a':
+            period = 'pm' if self.value.hour >= 12 else 'am'
+            context = 'format'
+        else:
+            period = get_period_id(self.value, locale=self.locale)
+            context = 'format' if char == 'B' else 'stand-alone'
+        for width in widths:
+            period_names = get_period_names(context=context, width=width, locale=self.locale)
+            if period in period_names:
+                return period_names[period]
+        raise ValueError(f"Could not format period {period} in {self.locale}")
+
+    def format_frac_seconds(self, num: int) -> str:
+        """ Return fractional seconds.
+
+        Rounds the time's microseconds to the precision given by the number \
+        of digits passed in.
+        """
+        value = self.value.microsecond / 1000000
+        return self.format(round(value, num) * 10**num, num)
+
+    def format_milliseconds_in_day(self, num):
+        msecs = (
+            self.value.microsecond // 1000
+            + self.value.second * 1000
+            + self.value.minute * 60000
+            + self.value.hour * 3600000
+        )
+        return self.format(msecs, num)
+
+    def format_timezone(self, char: str, num: int) -> str:
+        width = {3: 'short', 4: 'long', 5: 'iso8601'}[max(3, num)]
+
+        # It could be that we only receive a time to format, but also have a
+        # reference date which is important to distinguish between timezone
+        # variants (summer/standard time)
+        value = self.value
+        if self.reference_date:
+            value = datetime.datetime.combine(self.reference_date, self.value)
+
+        if char == 'z':
+            return get_timezone_name(value, width, locale=self.locale)
+        elif char == 'Z':
+            if num == 5:
+                return get_timezone_gmt(value, width, locale=self.locale, return_z=True)
+            return get_timezone_gmt(value, width, locale=self.locale)
+        elif char == 'O':
+            if num == 4:
+                return get_timezone_gmt(value, width, locale=self.locale)
+        # TODO: To add support for O:1
+        elif char == 'v':
+            return get_timezone_name(value.tzinfo, width, locale=self.locale)
+        elif char == 'V':
+            if num == 1:
+                return get_timezone_name(value.tzinfo, width, locale=self.locale)
+            elif num == 2:
+                return get_timezone_name(value.tzinfo, locale=self.locale, return_zone=True)
+            elif num == 3:
+                return get_timezone_location(value.tzinfo, locale=self.locale, return_city=True)  # fmt: skip
+            return get_timezone_location(value.tzinfo, locale=self.locale)
+        elif char in 'Xx':
+            return_z = char == 'X'
+            if num == 1:
+                width = 'iso8601_short'
+            elif num in (2, 4):
+                width = 'short'
+            elif num in (3, 5):
+                width = 'iso8601'
+            return get_timezone_gmt(value, width=width, locale=self.locale, return_z=return_z)  # fmt: skip
+
+    def format(self, value: SupportsInt, length: int) -> str:
+        return '%0*d' % (length, value)
+
+    def get_day_of_year(self, date: datetime.date | None = None) -> int:
+        if date is None:
+            date = self.value
+        return (date - date.replace(month=1, day=1)).days + 1
+
+    def get_week_of_year(self) -> int:
+        """Return the week of the year."""
+        day_of_year = self.get_day_of_year(self.value)
+        week = self.get_week_number(day_of_year)
+        if week == 0:
+            date = datetime.date(self.value.year - 1, 12, 31)
+            week = self.get_week_number(self.get_day_of_year(date), date.weekday())
+        elif week > 52:
+            weekday = datetime.date(self.value.year + 1, 1, 1).weekday()
+            if (
+                self.get_week_number(1, weekday) == 1
+                and 32 - (weekday - self.locale.first_week_day) % 7 <= self.value.day
+            ):
+                week = 1
+        return week
+
+    def get_week_of_month(self) -> int:
+        """Return the week of the month."""
+        return self.get_week_number(self.value.day)
+
+    def get_week_number(self, day_of_period: int, day_of_week: int | None = None) -> int:
+        """Return the number of the week of a day within a period. This may be
+        the week number in a year or the week number in a month.
+
+        Usually this will return a value equal to or greater than 1, but if the
+        first week of the period is so short that it actually counts as the last
+        week of the previous period, this function will return 0.
+
+        >>> date = datetime.date(2006, 1, 8)
+        >>> DateTimeFormat(date, 'de_DE').get_week_number(6)
+        1
+        >>> DateTimeFormat(date, 'en_US').get_week_number(6)
+        2
+
+        :param day_of_period: the number of the day in the period (usually
+                              either the day of month or the day of year)
+        :param day_of_week: the week day; if omitted, the week day of the
+                            current date is assumed
+        """
+        if day_of_week is None:
+            day_of_week = self.value.weekday()
+        first_day = (day_of_week - self.locale.first_week_day - day_of_period + 1) % 7
+        if first_day < 0:
+            first_day += 7
+        week_number = (day_of_period + first_day - 1) // 7
+        if 7 - first_day >= self.locale.min_week_days:
+            week_number += 1
+        return week_number
+
+
+PATTERN_CHARS: dict[str, list[int] | None] = {
+    'G': [1, 2, 3, 4, 5],                                               # era
+    'y': None, 'Y': None, 'u': None,                                    # year
+    'Q': [1, 2, 3, 4, 5], 'q': [1, 2, 3, 4, 5],                         # quarter
+    'M': [1, 2, 3, 4, 5], 'L': [1, 2, 3, 4, 5],                         # month
+    'w': [1, 2], 'W': [1],                                              # week
+    'd': [1, 2], 'D': [1, 2, 3], 'F': [1], 'g': None,                   # day
+    'E': [1, 2, 3, 4, 5, 6], 'e': [1, 2, 3, 4, 5, 6], 'c': [1, 3, 4, 5, 6],  # week day
+    'a': [1, 2, 3, 4, 5], 'b': [1, 2, 3, 4, 5], 'B': [1, 2, 3, 4, 5],   # period
+    'h': [1, 2], 'H': [1, 2], 'K': [1, 2], 'k': [1, 2],                 # hour
+    'm': [1, 2],                                                        # minute
+    's': [1, 2], 'S': None, 'A': None,                                  # second
+    'z': [1, 2, 3, 4], 'Z': [1, 2, 3, 4, 5], 'O': [1, 4], 'v': [1, 4],  # zone
+    'V': [1, 2, 3, 4], 'x': [1, 2, 3, 4, 5], 'X': [1, 2, 3, 4, 5],      # zone
+}  # fmt: skip
+
+#: The pattern characters declared in the Date Field Symbol Table
+#: (https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table)
+#: in order of decreasing magnitude.
+PATTERN_CHAR_ORDER = "GyYuUQqMLlwWdDFgEecabBChHKkjJmsSAzZOvVXx"
+
+
+def parse_pattern(pattern: str | DateTimePattern) -> DateTimePattern:
+    """Parse date, time, and datetime format patterns.
+
+    >>> parse_pattern("MMMMd").format
+    '%(MMMM)s%(d)s'
+    >>> parse_pattern("MMM d, yyyy").format
+    '%(MMM)s %(d)s, %(yyyy)s'
+
+    Pattern can contain literal strings in single quotes:
+
+    >>> parse_pattern("H:mm' Uhr 'z").format
+    '%(H)s:%(mm)s Uhr %(z)s'
+
+    An actual single quote can be used by using two adjacent single quote
+    characters:
+
+    >>> parse_pattern("hh' o''clock'").format
+    "%(hh)s o'clock"
+
+    :param pattern: the formatting pattern to parse
+    """
+    if isinstance(pattern, DateTimePattern):
+        return pattern
+    return _cached_parse_pattern(pattern)
+
+
+@lru_cache(maxsize=1024)
+def _cached_parse_pattern(pattern: str) -> DateTimePattern:
+    result = []
+
+    for tok_type, tok_value in tokenize_pattern(pattern):
+        if tok_type == "chars":
+            result.append(tok_value.replace('%', '%%'))
+        elif tok_type == "field":
+            fieldchar, fieldnum = tok_value
+            limit = PATTERN_CHARS[fieldchar]
+            if limit and fieldnum not in limit:
+                raise ValueError(f"Invalid length for field: {fieldchar * fieldnum!r}")
+            result.append('%%(%s)s' % (fieldchar * fieldnum))
+        else:
+            raise NotImplementedError(f"Unknown token type: {tok_type}")
+    return DateTimePattern(pattern, ''.join(result))
+
+
+def tokenize_pattern(pattern: str) -> list[tuple[str, str | tuple[str, int]]]:
+    """
+    Tokenize date format patterns.
+
+    Returns a list of (token_type, token_value) tuples.
+
+    ``token_type`` may be either "chars" or "field".
+
+    For "chars" tokens, the value is the literal value.
+
+    For "field" tokens, the value is a tuple of (field character, repetition count).
+
+    :param pattern: Pattern string
+    :type pattern: str
+    :rtype: list[tuple]
+    """
+    result = []
+    quotebuf = None
+    charbuf = []
+    fieldchar = ['']
+    fieldnum = [0]
+
+    def append_chars():
+        result.append(('chars', ''.join(charbuf).replace('\0', "'")))
+        del charbuf[:]
+
+    def append_field():
+        result.append(('field', (fieldchar[0], fieldnum[0])))
+        fieldchar[0] = ''
+        fieldnum[0] = 0
+
+    for char in pattern.replace("''", '\0'):
+        if quotebuf is None:
+            if char == "'":  # quote started
+                if fieldchar[0]:
+                    append_field()
+                elif charbuf:
+                    append_chars()
+                quotebuf = []
+            elif char in PATTERN_CHARS:
+                if charbuf:
+                    append_chars()
+                if char == fieldchar[0]:
+                    fieldnum[0] += 1
+                else:
+                    if fieldchar[0]:
+                        append_field()
+                    fieldchar[0] = char
+                    fieldnum[0] = 1
+            else:
+                if fieldchar[0]:
+                    append_field()
+                charbuf.append(char)
+
+        elif quotebuf is not None:
+            if char == "'":  # end of quote
+                charbuf.extend(quotebuf)
+                quotebuf = None
+            else:  # inside quote
+                quotebuf.append(char)
+
+    if fieldchar[0]:
+        append_field()
+    elif charbuf:
+        append_chars()
+
+    return result
+
+
+def untokenize_pattern(tokens: Iterable[tuple[str, str | tuple[str, int]]]) -> str:
+    """
+    Turn a date format pattern token stream back into a string.
+
+    This is the reverse operation of ``tokenize_pattern``.
+
+    :type tokens: Iterable[tuple]
+    :rtype: str
+    """
+    output = []
+    for tok_type, tok_value in tokens:
+        if tok_type == "field":
+            output.append(tok_value[0] * tok_value[1])
+        elif tok_type == "chars":
+            if not any(ch in PATTERN_CHARS for ch in tok_value):  # No need to quote
+                output.append(tok_value)
+            else:
+                output.append("'%s'" % tok_value.replace("'", "''"))
+    return "".join(output)
+
+
+def split_interval_pattern(pattern: str) -> list[str]:
+    """
+    Split an interval-describing datetime pattern into multiple pieces.
+
+    > The pattern is then designed to be broken up into two pieces by determining the first repeating field.
+    - https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
+
+    >>> split_interval_pattern('E d.M. – E d.M.')
+    ['E d.M. – ', 'E d.M.']
+    >>> split_interval_pattern("Y 'text' Y 'more text'")
+    ["Y 'text '", "Y 'more text'"]
+    >>> split_interval_pattern('E, MMM d – E')
+    ['E, MMM d – ', 'E']
+    >>> split_interval_pattern("MMM d")
+    ['MMM d']
+    >>> split_interval_pattern("y G")
+    ['y G']
+    >>> split_interval_pattern('MMM d – d')
+    ['MMM d – ', 'd']
+
+    :param pattern: Interval pattern string
+    :return: list of "subpatterns"
+    """
+
+    seen_fields = set()
+    parts = [[]]
+
+    for tok_type, tok_value in tokenize_pattern(pattern):
+        if tok_type == "field":
+            if tok_value[0] in seen_fields:  # Repeated field
+                parts.append([])
+                seen_fields.clear()
+            seen_fields.add(tok_value[0])
+        parts[-1].append((tok_type, tok_value))
+
+    return [untokenize_pattern(tokens) for tokens in parts]
+
+
+def match_skeleton(
+    skeleton: str,
+    options: Iterable[str],
+    allow_different_fields: bool = False,
+) -> str | None:
+    """
+    Find the closest match for the given datetime skeleton among the options given.
+
+    This uses the rules outlined in the TR35 document.
+
+    >>> match_skeleton('yMMd', ('yMd', 'yMMMd'))
+    'yMd'
+
+    >>> match_skeleton('yMMd', ('jyMMd',), allow_different_fields=True)
+    'jyMMd'
+
+    >>> match_skeleton('yMMd', ('qyMMd',), allow_different_fields=False)
+
+    >>> match_skeleton('hmz', ('hmv',))
+    'hmv'
+
+    :param skeleton: The skeleton to match
+    :type skeleton: str
+    :param options: An iterable of other skeletons to match against
+    :type options: Iterable[str]
+    :param allow_different_fields: Whether to allow a match that uses different fields
+                                   than the skeleton requested.
+    :type allow_different_fields: bool
+
+    :return: The closest skeleton match, or if no match was found, None.
+    :rtype: str|None
+    """
+
+    # TODO: maybe implement pattern expansion?
+
+    # Based on the implementation in
+    # https://github.com/unicode-org/icu/blob/main/icu4j/main/core/src/main/java/com/ibm/icu/text/DateIntervalInfo.java
+
+    # Filter out falsy values and sort for stability; when `interval_formats` is passed in, there may be a None key.
+    options = sorted(option for option in options if option)
+
+    if 'z' in skeleton and not any('z' in option for option in options):
+        skeleton = skeleton.replace('z', 'v')
+    if 'k' in skeleton and not any('k' in option for option in options):
+        skeleton = skeleton.replace('k', 'H')
+    if 'K' in skeleton and not any('K' in option for option in options):
+        skeleton = skeleton.replace('K', 'h')
+    if 'a' in skeleton and not any('a' in option for option in options):
+        skeleton = skeleton.replace('a', '')
+    if 'b' in skeleton and not any('b' in option for option in options):
+        skeleton = skeleton.replace('b', '')
+
+    get_input_field_width = dict(t[1] for t in tokenize_pattern(skeleton) if t[0] == "field").get  # fmt: skip
+    best_skeleton = None
+    best_distance = None
+    for option in options:
+        get_opt_field_width = dict(t[1] for t in tokenize_pattern(option) if t[0] == "field").get  # fmt: skip
+        distance = 0
+        for field in PATTERN_CHARS:
+            input_width = get_input_field_width(field, 0)
+            opt_width = get_opt_field_width(field, 0)
+            if input_width == opt_width:
+                continue
+            if opt_width == 0 or input_width == 0:
+                if not allow_different_fields:  # This one is not okay
+                    option = None
+                    break
+                # Magic weight constant for "entirely different fields"
+                distance += 0x1000
+            elif field == 'M' and (
+                (input_width > 2 and opt_width <= 2) or (input_width <= 2 and opt_width > 2)
+            ):
+                # Magic weight constant for "text turns into a number"
+                distance += 0x100
+            else:
+                distance += abs(input_width - opt_width)
+
+        if not option:
+            # We lost the option along the way (probably due to "allow_different_fields")
+            continue
+
+        if not best_skeleton or distance < best_distance:
+            best_skeleton = option
+            best_distance = distance
+
+        if distance == 0:  # Found a perfect match!
+            break
+
+    return best_skeleton

micromamba_root/Lib/site-packages/babel/languages.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from babel.core import get_global
+
+
+def get_official_languages(
+    territory: str,
+    regional: bool = False,
+    de_facto: bool = False,
+) -> tuple[str, ...]:
+    """
+    Get the official language(s) for the given territory.
+
+    The language codes, if any are known, are returned in order of descending popularity.
+
+    If the `regional` flag is set, then languages which are regionally official are also returned.
+
+    If the `de_facto` flag is set, then languages which are "de facto" official are also returned.
+
+    .. warning:: Note that the data is as up to date as the current version of the CLDR used
+                 by Babel.  If you need scientifically accurate information, use another source!
+
+    :param territory: Territory code
+    :type territory: str
+    :param regional: Whether to return regionally official languages too
+    :type regional: bool
+    :param de_facto: Whether to return de-facto official languages too
+    :type de_facto: bool
+    :return: Tuple of language codes
+    :rtype: tuple[str]
+    """
+
+    territory = str(territory).upper()
+    allowed_stati = {"official"}
+    if regional:
+        allowed_stati.add("official_regional")
+    if de_facto:
+        allowed_stati.add("de_facto_official")
+
+    languages = get_global("territory_languages").get(territory, {})
+    pairs = [
+        (info['population_percent'], language)
+        for language, info in languages.items()
+        if info.get('official_status') in allowed_stati
+    ]
+    pairs.sort(reverse=True)
+    return tuple(lang for _, lang in pairs)
+
+
+def get_territory_language_info(
+    territory: str,
+) -> dict[str, dict[str, float | str | None]]:
+    """
+    Get a dictionary of language information for a territory.
+
+    The dictionary is keyed by language code; the values are dicts with more information.
+
+    The following keys are currently known for the values:
+
+    * `population_percent`: The percentage of the territory's population speaking the
+                            language.
+    * `official_status`: An optional string describing the officiality status of the language.
+                         Known values are "official", "official_regional" and "de_facto_official".
+
+    .. warning:: Note that the data is as up to date as the current version of the CLDR used
+                 by Babel.  If you need scientifically accurate information, use another source!
+
+    .. note:: Note that the format of the dict returned may change between Babel versions.
+
+    See https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html
+
+    :param territory: Territory code
+    :type territory: str
+    :return: Language information dictionary
+    :rtype: dict[str, dict]
+    """
+    territory = str(territory).upper()
+    return get_global("territory_languages").get(territory, {}).copy()

micromamba_root/Lib/site-packages/babel/lists.py

@@ -0,0 +1,141 @@
+"""
+babel.lists
+~~~~~~~~~~~
+
+Locale dependent formatting of lists.
+
+The default locale for the functions in this module is determined by the
+following environment variables, in that order:
+
+ * ``LC_ALL``, and
+ * ``LANG``
+
+:copyright: (c) 2015-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Sequence
+from typing import Literal
+
+from babel.core import Locale, default_locale
+
+_DEFAULT_LOCALE = default_locale()  # TODO(3.0): Remove this.
+
+
+def __getattr__(name):
+    if name == "DEFAULT_LOCALE":
+        warnings.warn(
+            "The babel.lists.DEFAULT_LOCALE constant is deprecated and will be removed.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _DEFAULT_LOCALE
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def format_list(
+    lst: Sequence[str],
+    style: Literal[
+        'standard',
+        'standard-short',
+        'or',
+        'or-short',
+        'unit',
+        'unit-short',
+        'unit-narrow',
+    ] = 'standard',
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Format the items in `lst` as a list.
+
+    >>> format_list(['apples', 'oranges', 'pears'], locale='en')
+    'apples, oranges, and pears'
+    >>> format_list(['apples', 'oranges', 'pears'], locale='zh')
+    'apples、oranges和pears'
+    >>> format_list(['omena', 'peruna', 'aplari'], style='or', locale='fi')
+    'omena, peruna tai aplari'
+
+    Not all styles are necessarily available in all locales.
+    The function will attempt to fall back to replacement styles according to the rules
+    set forth in the CLDR root XML file, and raise a ValueError if no suitable replacement
+    can be found.
+
+    The following text is verbatim from the Unicode TR35-49 spec [1].
+
+    * standard:
+      A typical 'and' list for arbitrary placeholders.
+      eg. "January, February, and March"
+    * standard-short:
+      A short version of an 'and' list, suitable for use with short or abbreviated placeholder values.
+      eg. "Jan., Feb., and Mar."
+    * or:
+      A typical 'or' list for arbitrary placeholders.
+      eg. "January, February, or March"
+    * or-short:
+      A short version of an 'or' list.
+      eg. "Jan., Feb., or Mar."
+    * unit:
+      A list suitable for wide units.
+      eg. "3 feet, 7 inches"
+    * unit-short:
+      A list suitable for short units
+      eg. "3 ft, 7 in"
+    * unit-narrow:
+      A list suitable for narrow units, where space on the screen is very limited.
+      eg. "3′ 7″"
+
+    [1]: https://www.unicode.org/reports/tr35/tr35-49/tr35-general.html#ListPatterns
+
+    :param lst: a sequence of items to format in to a list
+    :param style: the style to format the list with. See above for description.
+    :param locale: the locale. Defaults to the system locale.
+    """
+    locale = Locale.parse(locale or _DEFAULT_LOCALE)
+    if not lst:
+        return ''
+    if len(lst) == 1:
+        return lst[0]
+
+    patterns = _resolve_list_style(locale, style)
+
+    if len(lst) == 2 and '2' in patterns:
+        return patterns['2'].format(*lst)
+
+    result = patterns['start'].format(lst[0], lst[1])
+    for elem in lst[2:-1]:
+        result = patterns['middle'].format(result, elem)
+    result = patterns['end'].format(result, lst[-1])
+
+    return result
+
+
+# Based on CLDR 45's root.xml file's `<alias>`es.
+# The root file defines both `standard` and `or`,
+# so they're always available.
+# TODO: It would likely be better to use the
+#       babel.localedata.Alias mechanism for this,
+#       but I'm not quite sure how it's supposed to
+#       work with inheritance and data in the root.
+_style_fallbacks = {
+    "or-narrow": ["or-short", "or"],
+    "or-short": ["or"],
+    "standard-narrow": ["standard-short", "standard"],
+    "standard-short": ["standard"],
+    "unit": ["unit-short", "standard"],
+    "unit-narrow": ["unit-short", "unit", "standard"],
+    "unit-short": ["standard"],
+}
+
+
+def _resolve_list_style(locale: Locale, style: str):
+    for style in (style, *(_style_fallbacks.get(style, []))):  # noqa: B020
+        if style in locale.list_patterns:
+            return locale.list_patterns[style]
+    raise ValueError(
+        f"Locale {locale} does not support list formatting style {style!r} "
+        f"(supported are {sorted(locale.list_patterns)})",
+    )

micromamba_root/Lib/site-packages/babel/localedata.py

@@ -0,0 +1,284 @@
+"""
+babel.localedata
+~~~~~~~~~~~~~~~~
+
+Low-level locale data access.
+
+:note: The `Locale` class, which uses this module under the hood, provides a
+       more convenient interface for accessing the locale data.
+
+:copyright: (c) 2013-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+import re
+import sys
+import threading
+from collections import abc
+from collections.abc import Iterator, Mapping, MutableMapping
+from functools import lru_cache
+from itertools import chain
+from typing import Any
+
+_cache: dict[str, Any] = {}
+_cache_lock = threading.RLock()
+_dirname = os.path.join(os.path.dirname(__file__), 'locale-data')
+_windows_reserved_name_re = re.compile("^(con|prn|aux|nul|com[0-9]|lpt[0-9])$", re.I)
+
+
+def normalize_locale(name: str) -> str | None:
+    """Normalize a locale ID by stripping spaces and apply proper casing.
+
+    Returns the normalized locale ID string or `None` if the ID is not
+    recognized.
+    """
+    if not name or not isinstance(name, str):
+        return None
+    name = name.strip().lower()
+    for locale_id in chain.from_iterable([_cache, locale_identifiers()]):
+        if name == locale_id.lower():
+            return locale_id
+
+
+def resolve_locale_filename(name: os.PathLike[str] | str) -> str:
+    """
+    Resolve a locale identifier to a `.dat` path on disk.
+    """
+
+    # Clean up any possible relative paths.
+    name = os.path.basename(name)
+
+    # Ensure we're not left with one of the Windows reserved names.
+    if sys.platform == "win32" and _windows_reserved_name_re.match(os.path.splitext(name)[0]):
+        raise ValueError(f"Name {name} is invalid on Windows")
+
+    # Build the path.
+    return os.path.join(_dirname, f"{name}.dat")
+
+
+def exists(name: str) -> bool:
+    """Check whether locale data is available for the given locale.
+
+    Returns `True` if it exists, `False` otherwise.
+
+    :param name: the locale identifier string
+    """
+    if not name or not isinstance(name, str):
+        return False
+    if name in _cache:
+        return True
+    file_found = os.path.exists(resolve_locale_filename(name))
+    return True if file_found else bool(normalize_locale(name))
+
+
+@lru_cache(maxsize=None)
+def locale_identifiers() -> list[str]:
+    """Return a list of all locale identifiers for which locale data is
+    available.
+
+    This data is cached after the first invocation.
+    You can clear the cache by calling `locale_identifiers.cache_clear()`.
+
+    .. versionadded:: 0.8.1
+
+    :return: a list of locale identifiers (strings)
+    """
+    return [
+        stem
+        for stem, extension in (
+            os.path.splitext(filename) for filename in os.listdir(_dirname)
+        )
+        if extension == '.dat' and stem != 'root'
+    ]
+
+
+def _is_non_likely_script(name: str) -> bool:
+    """Return whether the locale is of the form ``lang_Script``,
+    and the script is not the likely script for the language.
+
+    This implements the behavior of the ``nonlikelyScript`` value of the
+    ``localRules`` attribute for parent locales added in CLDR 45.
+    """
+    from babel.core import get_global, parse_locale
+
+    try:
+        lang, territory, script, variant, *rest = parse_locale(name)
+    except ValueError:
+        return False
+
+    if lang and script and not territory and not variant and not rest:
+        likely_subtag = get_global('likely_subtags').get(lang)
+        _, _, likely_script, *_ = parse_locale(likely_subtag)
+        return script != likely_script
+    return False
+
+
+def load(name: os.PathLike[str] | str, merge_inherited: bool = True) -> dict[str, Any]:
+    """Load the locale data for the given locale.
+
+    The locale data is a dictionary that contains much of the data defined by
+    the Common Locale Data Repository (CLDR). This data is stored as a
+    collection of pickle files inside the ``babel`` package.
+
+    >>> d = load('en_US')
+    >>> d['languages']['sv']
+    'Swedish'
+
+    Note that the results are cached, and subsequent requests for the same
+    locale return the same dictionary:
+
+    >>> d1 = load('en_US')
+    >>> d2 = load('en_US')
+    >>> d1 is d2
+    True
+
+    :param name: the locale identifier string (or "root")
+    :param merge_inherited: whether the inherited data should be merged into
+                            the data of the requested locale
+    :raise `IOError`: if no locale data file is found for the given locale
+                      identifier, or one of the locales it inherits from
+    """
+    name = os.path.basename(name)
+    _cache_lock.acquire()
+    try:
+        data = _cache.get(name)
+        if not data:
+            # Load inherited data
+            if name == 'root' or not merge_inherited:
+                data = {}
+            else:
+                from babel.core import get_global
+
+                parent = get_global('parent_exceptions').get(name)
+                if not parent:
+                    if _is_non_likely_script(name):
+                        parent = 'root'
+                    else:
+                        parts = name.split('_')
+                        parent = "root" if len(parts) == 1 else "_".join(parts[:-1])
+                data = load(parent).copy()
+            filename = resolve_locale_filename(name)
+            with open(filename, 'rb') as fileobj:
+                if name != 'root' and merge_inherited:
+                    merge(data, pickle.load(fileobj))
+                else:
+                    data = pickle.load(fileobj)
+            _cache[name] = data
+        return data
+    finally:
+        _cache_lock.release()
+
+
+def merge(dict1: MutableMapping[Any, Any], dict2: Mapping[Any, Any]) -> None:
+    """Merge the data from `dict2` into the `dict1` dictionary, making copies
+    of nested dictionaries.
+
+    >>> d = {1: 'foo', 3: 'baz'}
+    >>> merge(d, {1: 'Foo', 2: 'Bar'})
+    >>> sorted(d.items())
+    [(1, 'Foo'), (2, 'Bar'), (3, 'baz')]
+
+    :param dict1: the dictionary to merge into
+    :param dict2: the dictionary containing the data that should be merged
+    """
+    for key, val2 in dict2.items():
+        if val2 is not None:
+            val1 = dict1.get(key)
+            if isinstance(val2, dict):
+                if val1 is None:
+                    val1 = {}
+                if isinstance(val1, Alias):
+                    val1 = (val1, val2)
+                elif isinstance(val1, tuple):
+                    alias, others = val1
+                    others = others.copy()
+                    merge(others, val2)
+                    val1 = (alias, others)
+                else:
+                    val1 = val1.copy()
+                    merge(val1, val2)
+            else:
+                val1 = val2
+            dict1[key] = val1
+
+
+class Alias:
+    """Representation of an alias in the locale data.
+
+    An alias is a value that refers to some other part of the locale data,
+    as specified by the `keys`.
+    """
+
+    def __init__(self, keys: tuple[str, ...]) -> None:
+        self.keys = tuple(keys)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.keys!r}>"
+
+    def resolve(self, data: Mapping[str | int | None, Any]) -> Mapping[str | int | None, Any]:
+        """Resolve the alias based on the given data.
+
+        This is done recursively, so if one alias resolves to a second alias,
+        that second alias will also be resolved.
+
+        :param data: the locale data
+        :type data: `dict`
+        """
+        base = data
+        for key in self.keys:
+            data = data[key]
+        if isinstance(data, Alias):
+            data = data.resolve(base)
+        elif isinstance(data, tuple):
+            alias, others = data
+            data = alias.resolve(base)
+        return data
+
+
+class LocaleDataDict(abc.MutableMapping):
+    """Dictionary wrapper that automatically resolves aliases to the actual
+    values.
+    """
+
+    def __init__(
+        self,
+        data: MutableMapping[str | int | None, Any],
+        base: Mapping[str | int | None, Any] | None = None,
+    ):
+        self._data = data
+        if base is None:
+            base = data
+        self.base = base
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __iter__(self) -> Iterator[str | int | None]:
+        return iter(self._data)
+
+    def __getitem__(self, key: str | int | None) -> Any:
+        orig = val = self._data[key]
+        if isinstance(val, Alias):  # resolve an alias
+            val = val.resolve(self.base)
+        if isinstance(val, tuple):  # Merge a partial dict with an alias
+            alias, others = val
+            val = alias.resolve(self.base).copy()
+            merge(val, others)
+        if isinstance(val, dict):  # Return a nested alias-resolving dict
+            val = LocaleDataDict(val, base=self.base)
+        if val is not orig:
+            self._data[key] = val
+        return val
+
+    def __setitem__(self, key: str | int | None, value: Any) -> None:
+        self._data[key] = value
+
+    def __delitem__(self, key: str | int | None) -> None:
+        del self._data[key]
+
+    def copy(self) -> LocaleDataDict:
+        return LocaleDataDict(self._data.copy(), base=self.base)

micromamba_root/Lib/site-packages/babel/numbers.py

@@ -0,0 +1,1681 @@
+"""
+babel.numbers
+~~~~~~~~~~~~~
+
+Locale dependent formatting and parsing of numeric data.
+
+The default locale for the functions in this module is determined by the
+following environment variables, in that order:
+
+ * ``LC_MONETARY`` for currency related functions,
+ * ``LC_NUMERIC``, and
+ * ``LC_ALL``, and
+ * ``LANG``
+
+:copyright: (c) 2013-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+# TODO:
+#  Padding and rounding increments in pattern:
+#  - https://www.unicode.org/reports/tr35/ (Appendix G.6)
+from __future__ import annotations
+
+import datetime
+import decimal
+import re
+import warnings
+from typing import Any, Literal, cast, overload
+
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
+
+LC_MONETARY = default_locale(('LC_MONETARY', 'LC_NUMERIC'))
+LC_NUMERIC = default_locale('LC_NUMERIC')
+
+
+class UnknownCurrencyError(Exception):
+    """Exception thrown when a currency is requested for which no data is available."""
+
+    def __init__(self, identifier: str) -> None:
+        """Create the exception.
+        :param identifier: the identifier string of the unsupported currency
+        """
+        Exception.__init__(self, f"Unknown currency {identifier!r}.")
+
+        #: The identifier of the locale that could not be found.
+        self.identifier = identifier
+
+
+def list_currencies(locale: Locale | str | None = None) -> set[str]:
+    """Return a `set` of normalized currency codes.
+
+    .. versionadded:: 2.5.0
+
+    :param locale: filters returned currency codes by the provided locale.
+                   Expected to be a locale instance or code. If no locale is
+                   provided, returns the list of all currencies from all
+                   locales.
+    """
+    # Get locale-scoped currencies.
+    if locale:
+        return set(Locale.parse(locale).currencies)
+    return set(get_global('all_currencies'))
+
+
+def validate_currency(currency: str, locale: Locale | str | None = None) -> None:
+    """Check the currency code is recognized by Babel.
+
+    Accepts a ``locale`` parameter for fined-grained validation, working as
+    the one defined above in ``list_currencies()`` method.
+
+    Raises a `UnknownCurrencyError` exception if the currency is unknown to Babel.
+    """
+    if currency not in list_currencies(locale):
+        raise UnknownCurrencyError(currency)
+
+
+def is_currency(currency: str, locale: Locale | str | None = None) -> bool:
+    """Returns `True` only if a currency is recognized by Babel.
+
+    This method always return a Boolean and never raise.
+    """
+    if not currency or not isinstance(currency, str):
+        return False
+    try:
+        validate_currency(currency, locale)
+    except UnknownCurrencyError:
+        return False
+    return True
+
+
+def normalize_currency(currency: str, locale: Locale | str | None = None) -> str | None:
+    """Returns the normalized identifier of any currency code.
+
+    Accepts a ``locale`` parameter for fined-grained validation, working as
+    the one defined above in ``list_currencies()`` method.
+
+    Returns None if the currency is unknown to Babel.
+    """
+    if isinstance(currency, str):
+        currency = currency.upper()
+    if not is_currency(currency, locale):
+        return None
+    return currency
+
+
+def get_currency_name(
+    currency: str,
+    count: float | decimal.Decimal | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    """Return the name used by the locale for the specified currency.
+
+    >>> get_currency_name('USD', locale='en_US')
+    'US Dollar'
+
+    .. versionadded:: 0.9.4
+
+    :param currency: the currency code.
+    :param count: the optional count.  If provided the currency name
+                  will be pluralized to that number if possible.
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    """
+    loc = Locale.parse(locale or LC_MONETARY)
+    if count is not None:
+        try:
+            plural_form = loc.plural_form(count)
+        except (OverflowError, ValueError):
+            plural_form = 'other'
+        plural_names = loc._data['currency_names_plural']
+        if currency in plural_names:
+            currency_plural_names = plural_names[currency]
+            if plural_form in currency_plural_names:
+                return currency_plural_names[plural_form]
+            if 'other' in currency_plural_names:
+                return currency_plural_names['other']
+    return loc.currencies.get(currency, currency)
+
+
+def get_currency_symbol(currency: str, locale: Locale | str | None = None) -> str:
+    """Return the symbol used by the locale for the specified currency.
+
+    >>> get_currency_symbol('USD', locale='en_US')
+    '$'
+
+    :param currency: the currency code.
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    """
+    return Locale.parse(locale or LC_MONETARY).currency_symbols.get(currency, currency)
+
+
+def get_currency_precision(currency: str) -> int:
+    """Return currency's precision.
+
+    Precision is the number of decimals found after the decimal point in the
+    currency's format pattern.
+
+    .. versionadded:: 2.5.0
+
+    :param currency: the currency code.
+    """
+    precisions = get_global('currency_fractions')
+    return precisions.get(currency, precisions['DEFAULT'])[0]
+
+
+def get_currency_unit_pattern(
+    currency: str,  # TODO: unused?!
+    count: float | decimal.Decimal | None = None,
+    locale: Locale | str | None = None,
+) -> str:
+    """
+    Return the unit pattern used for long display of a currency value
+    for a given locale.
+    This is a string containing ``{0}`` where the numeric part
+    should be substituted and ``{1}`` where the currency long display
+    name should be substituted.
+
+    >>> get_currency_unit_pattern('USD', locale='en_US', count=10)
+    '{0} {1}'
+
+    .. versionadded:: 2.7.0
+
+    :param currency: the currency code.
+    :param count: the optional count.  If provided the unit
+                  pattern for that number will be returned.
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    """
+    loc = Locale.parse(locale or LC_MONETARY)
+    if count is not None:
+        plural_form = loc.plural_form(count)
+        try:
+            return loc._data['currency_unit_patterns'][plural_form]
+        except LookupError:
+            # Fall back to 'other'
+            pass
+
+    return loc._data['currency_unit_patterns']['other']
+
+
+@overload
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = ...,
+    end_date: datetime.date | None = ...,
+    tender: bool = ...,
+    non_tender: bool = ...,
+    include_details: Literal[False] = ...,
+) -> list[str]: ...  # pragma: no cover
+
+
+@overload
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = ...,
+    end_date: datetime.date | None = ...,
+    tender: bool = ...,
+    non_tender: bool = ...,
+    include_details: Literal[True] = ...,
+) -> list[dict[str, Any]]: ...  # pragma: no cover
+
+
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = None,
+    end_date: datetime.date | None = None,
+    tender: bool = True,
+    non_tender: bool = False,
+    include_details: bool = False,
+) -> list[str] | list[dict[str, Any]]:
+    """Returns the list of currencies for the given territory that are valid for
+    the given date range.  In addition to that the currency database
+    distinguishes between tender and non-tender currencies.  By default only
+    tender currencies are returned.
+
+    The return value is a list of all currencies roughly ordered by the time
+    of when the currency became active.  The longer the currency is being in
+    use the more to the left of the list it will be.
+
+    The start date defaults to today.  If no end date is given it will be the
+    same as the start date.  Otherwise a range can be defined.  For instance
+    this can be used to find the currencies in use in Austria between 1995 and
+    2011:
+
+    >>> from datetime import date
+    >>> get_territory_currencies('AT', date(1995, 1, 1), date(2011, 1, 1))
+    ['ATS', 'EUR']
+
+    Likewise it's also possible to find all the currencies in use on a
+    single date:
+
+    >>> get_territory_currencies('AT', date(1995, 1, 1))
+    ['ATS']
+    >>> get_territory_currencies('AT', date(2011, 1, 1))
+    ['EUR']
+
+    By default the return value only includes tender currencies.  This
+    however can be changed:
+
+    >>> get_territory_currencies('US')
+    ['USD']
+    >>> get_territory_currencies('US', tender=False, non_tender=True,
+    ...                          start_date=date(2014, 1, 1))
+    ['USN', 'USS']
+
+    .. versionadded:: 2.0
+
+    :param territory: the name of the territory to find the currency for.
+    :param start_date: the start date.  If not given today is assumed.
+    :param end_date: the end date.  If not given the start date is assumed.
+    :param tender: controls whether tender currencies should be included.
+    :param non_tender: controls whether non-tender currencies should be
+                       included.
+    :param include_details: if set to `True`, instead of returning currency
+                            codes the return value will be dictionaries
+                            with detail information.  In that case each
+                            dictionary will have the keys ``'currency'``,
+                            ``'from'``, ``'to'``, and ``'tender'``.
+    """
+    currencies = get_global('territory_currencies')
+    if start_date is None:
+        start_date = datetime.date.today()
+    elif isinstance(start_date, datetime.datetime):
+        start_date = start_date.date()
+    if end_date is None:
+        end_date = start_date
+    elif isinstance(end_date, datetime.datetime):
+        end_date = end_date.date()
+
+    curs = currencies.get(territory.upper(), ())
+    # TODO: validate that the territory exists
+
+    def _is_active(start, end):
+        return (start is None or start <= end_date) and (end is None or end >= start_date)
+
+    result = []
+    for currency_code, start, end, is_tender in curs:
+        if start:
+            start = datetime.date(*start)
+        if end:
+            end = datetime.date(*end)
+        if ((is_tender and tender) or (not is_tender and non_tender)) and _is_active(
+            start,
+            end,
+        ):
+            if include_details:
+                result.append(
+                    {
+                        'currency': currency_code,
+                        'from': start,
+                        'to': end,
+                        'tender': is_tender,
+                    },
+                )
+            else:
+                result.append(currency_code)
+
+    return result
+
+
+def _get_numbering_system(
+    locale: Locale,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    if numbering_system == "default":
+        return locale.default_numbering_system
+    else:
+        return numbering_system
+
+
+def _get_number_symbols(
+    locale: Locale,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> LocaleDataDict:
+    numbering_system = _get_numbering_system(locale, numbering_system)
+    try:
+        return locale.number_symbols[numbering_system]
+    except KeyError as error:
+        raise UnsupportedNumberingSystemError(
+            f"Unknown numbering system {numbering_system} for Locale {locale}.",
+        ) from error
+
+
+class UnsupportedNumberingSystemError(Exception):
+    """Exception thrown when an unsupported numbering system is requested for the given Locale."""
+
+    pass
+
+
+def get_decimal_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate decimal fractions.
+
+    >>> get_decimal_symbol('en_US')
+    '.'
+    >>> get_decimal_symbol('ar_EG', numbering_system='default')
+    '٫'
+    >>> get_decimal_symbol('ar_EG', numbering_system='latn')
+    '.'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('decimal', '.')
+
+
+def get_plus_sign_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the plus sign symbol used by the current locale.
+
+    >>> get_plus_sign_symbol('en_US')
+    '+'
+    >>> get_plus_sign_symbol('ar_EG', numbering_system='default')
+    '\\u061c+'
+    >>> get_plus_sign_symbol('ar_EG', numbering_system='latn')
+    '\\u200e+'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('plusSign', '+')
+
+
+def get_minus_sign_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the plus sign symbol used by the current locale.
+
+    >>> get_minus_sign_symbol('en_US')
+    '-'
+    >>> get_minus_sign_symbol('ar_EG', numbering_system='default')
+    '\\u061c-'
+    >>> get_minus_sign_symbol('ar_EG', numbering_system='latn')
+    '\\u200e-'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('minusSign', '-')
+
+
+def get_exponential_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate mantissa and exponent.
+
+    >>> get_exponential_symbol('en_US')
+    'E'
+    >>> get_exponential_symbol('ar_EG', numbering_system='default')
+    'أس'
+    >>> get_exponential_symbol('ar_EG', numbering_system='latn')
+    'E'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('exponential', 'E')  # fmt: skip
+
+
+def get_group_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate groups of thousands.
+
+    >>> get_group_symbol('en_US')
+    ','
+    >>> get_group_symbol('ar_EG', numbering_system='default')
+    '٬'
+    >>> get_group_symbol('ar_EG', numbering_system='latn')
+    ','
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('group', ',')
+
+
+def get_infinity_symbol(
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to represent infinity.
+
+    >>> get_infinity_symbol('en_US')
+    '∞'
+    >>> get_infinity_symbol('ar_EG', numbering_system='default')
+    '∞'
+    >>> get_infinity_symbol('ar_EG', numbering_system='latn')
+    '∞'
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('infinity', '∞')
+
+
+def format_number(
+    number: float | decimal.Decimal | str,
+    locale: Locale | str | None = None,
+) -> str:
+    """Return the given number formatted for a specific locale.
+
+    >>> format_number(1099, locale='en_US')  # doctest: +SKIP
+    '1,099'
+    >>> format_number(1099, locale='de_DE')  # doctest: +SKIP
+    '1.099'
+
+    .. deprecated:: 2.6.0
+
+       Use babel.numbers.format_decimal() instead.
+
+    :param number: the number to format
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+
+
+    """
+    warnings.warn(
+        'Use babel.numbers.format_decimal() instead.',
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return format_decimal(number, locale=locale)
+
+
+def get_decimal_precision(number: decimal.Decimal) -> int:
+    """Return maximum precision of a decimal instance's fractional part.
+
+    Precision is extracted from the fractional part only.
+    """
+    # Copied from: https://github.com/mahmoud/boltons/pull/59
+    assert isinstance(number, decimal.Decimal)
+    decimal_tuple = number.normalize().as_tuple()
+    # Note: DecimalTuple.exponent can be 'n' (qNaN), 'N' (sNaN), or 'F' (Infinity)
+    if not isinstance(decimal_tuple.exponent, int) or decimal_tuple.exponent >= 0:
+        return 0
+    return abs(decimal_tuple.exponent)
+
+
+def get_decimal_quantum(precision: int | decimal.Decimal) -> decimal.Decimal:
+    """Return minimal quantum of a number, as defined by precision."""
+    assert isinstance(precision, (int, decimal.Decimal))
+    return decimal.Decimal(10) ** (-precision)
+
+
+def format_decimal(
+    number: float | decimal.Decimal | str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = None,
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the given decimal number formatted for a specific locale.
+
+    >>> format_decimal(1.2345, locale='en_US')
+    '1.234'
+    >>> format_decimal(1.2346, locale='en_US')
+    '1.235'
+    >>> format_decimal(-1.2346, locale='en_US')
+    '-1.235'
+    >>> format_decimal(1.2345, locale='sv_SE')
+    '1,234'
+    >>> format_decimal(1.2345, locale='de')
+    '1,234'
+    >>> format_decimal(1.2345, locale='ar_EG', numbering_system='default')
+    '1٫234'
+    >>> format_decimal(1.2345, locale='ar_EG', numbering_system='latn')
+    '1.234'
+
+    The appropriate thousands grouping and the decimal separator are used for
+    each locale:
+
+    >>> format_decimal(12345.5, locale='en_US')
+    '12,345.5'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_decimal(1.2346, locale='en_US')
+    '1.235'
+    >>> format_decimal(1.2346, locale='en_US', decimal_quantization=False)
+    '1.2346'
+    >>> format_decimal(12345.67, locale='fr_CA', group_separator=False)
+    '12345,67'
+    >>> format_decimal(12345.67, locale='en_US', group_separator=True)
+    '12,345.67'
+
+    :param number: the number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    if format is None:
+        format = locale.decimal_formats[format]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number,
+        locale,
+        decimal_quantization=decimal_quantization,
+        group_separator=group_separator,
+        numbering_system=numbering_system,
+    )
+
+
+def format_compact_decimal(
+    number: float | decimal.Decimal | str,
+    *,
+    format_type: Literal["short", "long"] = "short",
+    locale: Locale | str | None = None,
+    fraction_digits: int = 0,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the given decimal number formatted for a specific locale in compact form.
+
+    >>> format_compact_decimal(12345, format_type="short", locale='en_US')
+    '12K'
+    >>> format_compact_decimal(12345, format_type="long", locale='en_US')
+    '12 thousand'
+    >>> format_compact_decimal(12345, format_type="short", locale='en_US', fraction_digits=2)
+    '12.34K'
+    >>> format_compact_decimal(1234567, format_type="short", locale="ja_JP")
+    '123万'
+    >>> format_compact_decimal(2345678, format_type="long", locale="mk")
+    '2 милиони'
+    >>> format_compact_decimal(21000000, format_type="long", locale="mk")
+    '21 милион'
+    >>> format_compact_decimal(12345, format_type="short", locale='ar_EG', fraction_digits=2, numbering_system='default')
+    '12٫34\\xa0ألف'
+
+    :param number: the number to format
+    :param format_type: Compact format to use ("short" or "long")
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    compact_format = locale.compact_decimal_formats[format_type]
+    number, format = _get_compact_format(number, compact_format, locale, fraction_digits)
+    # Did not find a format, fall back.
+    if format is None:
+        format = locale.decimal_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number,
+        locale,
+        decimal_quantization=False,
+        numbering_system=numbering_system,
+    )
+
+
+def _get_compact_format(
+    number: float | decimal.Decimal | str,
+    compact_format: LocaleDataDict,
+    locale: Locale,
+    fraction_digits: int,
+) -> tuple[decimal.Decimal, NumberPattern | None]:
+    """Returns the number after dividing by the unit and the format pattern to use.
+    The algorithm is described here:
+    https://www.unicode.org/reports/tr35/tr35-45/tr35-numbers.html#Compact_Number_Formats.
+    """
+    if not isinstance(number, decimal.Decimal):
+        number = decimal.Decimal(str(number))
+    if number.is_nan() or number.is_infinite():
+        return number, None
+    format = None
+    for magnitude in sorted([int(m) for m in compact_format["other"]], reverse=True):
+        if abs(number) >= magnitude:
+            # check the pattern using "other" as the amount
+            format = compact_format["other"][str(magnitude)]
+            pattern = parse_pattern(format).pattern
+            # if the pattern is "0", we do not divide the number
+            if pattern == "0":
+                break
+            # otherwise, we need to divide the number by the magnitude but remove zeros
+            # equal to the number of 0's in the pattern minus 1
+            number = cast(
+                decimal.Decimal,
+                number / (magnitude // (10 ** (pattern.count("0") - 1))),
+            )
+            # round to the number of fraction digits requested
+            rounded = round(number, fraction_digits)
+            # if the remaining number is singular, use the singular format
+            plural_form = locale.plural_form(abs(number))
+            if plural_form not in compact_format:
+                plural_form = "other"
+            if number == 1 and "1" in compact_format:
+                plural_form = "1"
+            if str(magnitude) not in compact_format[plural_form]:
+                plural_form = "other"  # fall back to other as the implicit default
+            format = compact_format[plural_form][str(magnitude)]
+            number = rounded
+            break
+    return number, format
+
+
+class UnknownCurrencyFormatError(KeyError):
+    """Exception raised when an unknown currency format is requested."""
+
+
+def format_currency(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = None,
+    currency_digits: bool = True,
+    format_type: Literal["name", "standard", "accounting"] = "standard",
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return formatted currency value.
+
+    >>> format_currency(1099.98, 'USD', locale='en_US')
+    '$1,099.98'
+    >>> format_currency(1099.98, 'USD', locale='es_CO')
+    'US$1.099,98'
+    >>> format_currency(1099.98, 'EUR', locale='de_DE')
+    '1.099,98\\xa0\\u20ac'
+    >>> format_currency(1099.98, 'EGP', locale='ar_EG', numbering_system='default')
+    '\\u200f1٬099٫98\\xa0ج.م.\\u200f'
+
+    The format can also be specified explicitly.  The currency is
+    placed with the '¤' sign.  As the sign gets repeated the format
+    expands (¤ being the symbol, ¤¤ is the currency abbreviation and
+    ¤¤¤ is the full name of the currency):
+
+    >>> format_currency(1099.98, 'EUR', '\\xa4\\xa4 #,##0.00', locale='en_US')
+    'EUR 1,099.98'
+    >>> format_currency(1099.98, 'EUR', '#,##0.00 \\xa4\\xa4\\xa4', locale='en_US')
+    '1,099.98 euros'
+
+    Currencies usually have a specific number of decimal digits. This function
+    favours that information over the given format:
+
+    >>> format_currency(1099.98, 'JPY', locale='en_US')
+    '\\xa51,100'
+    >>> format_currency(1099.98, 'COP', '#,##0.00', locale='es_ES')
+    '1.099,98'
+
+    However, the number of decimal digits can be overridden from the currency
+    information, by setting the last parameter to ``False``:
+
+    >>> format_currency(1099.98, 'JPY', locale='en_US', currency_digits=False)
+    '\\xa51,099.98'
+    >>> format_currency(1099.98, 'COP', '#,##0.00', locale='es_ES', currency_digits=False)
+    '1.099,98'
+
+    If a format is not specified the type of currency format to use
+    from the locale can be specified:
+
+    >>> format_currency(1099.98, 'EUR', locale='en_US', format_type='standard')
+    '\\u20ac1,099.98'
+
+    When the given currency format type is not available, an exception is
+    raised:
+
+    >>> format_currency('1099.98', 'EUR', locale='root', format_type='unknown')
+    Traceback (most recent call last):
+        ...
+    UnknownCurrencyFormatError: "'unknown' is not a known currency format type"
+
+    >>> format_currency(101299.98, 'USD', locale='en_US', group_separator=False)
+    '$101299.98'
+
+    >>> format_currency(101299.98, 'USD', locale='en_US', group_separator=True)
+    '$101,299.98'
+
+    You can also pass format_type='name' to use long display names. The order of
+    the number and currency name, along with the correct localized plural form
+    of the currency name, is chosen according to locale:
+
+    >>> format_currency(1, 'USD', locale='en_US', format_type='name')
+    '1.00 US dollar'
+    >>> format_currency(1099.98, 'USD', locale='en_US', format_type='name')
+    '1,099.98 US dollars'
+    >>> format_currency(1099.98, 'USD', locale='ee', format_type='name')
+    'us ga dollar 1,099.98'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_currency(1099.9876, 'USD', locale='en_US')
+    '$1,099.99'
+    >>> format_currency(1099.9876, 'USD', locale='en_US', decimal_quantization=False)
+    '$1,099.9876'
+
+    :param number: the number to format
+    :param currency: the currency code
+    :param format: the format string to use
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    :param currency_digits: use the currency's natural number of decimal digits
+    :param format_type: the currency format type to use
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_MONETARY)
+
+    if format_type == 'name':
+        return _format_currency_long_name(
+            number,
+            currency,
+            locale=locale,
+            format=format,
+            currency_digits=currency_digits,
+            decimal_quantization=decimal_quantization,
+            group_separator=group_separator,
+            numbering_system=numbering_system,
+        )
+
+    if format:
+        pattern = parse_pattern(format)
+    else:
+        try:
+            pattern = locale.currency_formats[format_type]
+        except KeyError:
+            raise UnknownCurrencyFormatError(
+                f"{format_type!r} is not a known currency format type",
+            ) from None
+
+    return pattern.apply(
+        number,
+        locale,
+        currency=currency,
+        currency_digits=currency_digits,
+        decimal_quantization=decimal_quantization,
+        group_separator=group_separator,
+        numbering_system=numbering_system,
+    )
+
+
+def _format_currency_long_name(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    *,
+    locale: Locale,
+    format: str | NumberPattern | None,
+    currency_digits: bool,
+    decimal_quantization: bool,
+    group_separator: bool,
+    numbering_system: Literal["default"] | str,
+) -> str:
+    # Algorithm described here:
+    # https://www.unicode.org/reports/tr35/tr35-numbers.html#Currencies
+
+    # Step 1.
+    # There are no examples of items with explicit count (0 or 1) in current
+    # locale data. So there is no point implementing that.
+    # Step 2.
+
+    # Correct number to numeric type, important for looking up plural rules:
+    number_n = float(number) if isinstance(number, str) else number
+
+    # Step 3.
+    unit_pattern = get_currency_unit_pattern(currency, count=number_n, locale=locale)
+
+    # Step 4.
+    display_name = get_currency_name(currency, count=number_n, locale=locale)
+
+    # Step 5.
+    if not format:
+        format = locale.decimal_formats[None]
+
+    pattern = parse_pattern(format)
+
+    number_part = pattern.apply(
+        number,
+        locale,
+        currency=currency,
+        currency_digits=currency_digits,
+        decimal_quantization=decimal_quantization,
+        group_separator=group_separator,
+        numbering_system=numbering_system,
+    )
+
+    return unit_pattern.format(number_part, display_name)
+
+
+def format_compact_currency(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    *,
+    format_type: Literal["short"] = "short",
+    locale: Locale | str | None = None,
+    fraction_digits: int = 0,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Format a number as a currency value in compact form.
+
+    >>> format_compact_currency(12345, 'USD', locale='en_US')
+    '$12K'
+    >>> format_compact_currency(123456789, 'USD', locale='en_US', fraction_digits=2)
+    '$123.46M'
+    >>> format_compact_currency(123456789, 'EUR', locale='de_DE', fraction_digits=1)
+    '123,5\\xa0Mio.\\xa0€'
+
+    :param number: the number to format
+    :param currency: the currency code
+    :param format_type: the compact format type to use. Defaults to "short".
+    :param locale: the `Locale` object or locale identifier.
+                   Defaults to the system currency locale or numeric locale.
+    :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_MONETARY)
+    try:
+        compact_format = locale.compact_currency_formats[format_type]
+    except KeyError as error:
+        raise UnknownCurrencyFormatError(
+            f"{format_type!r} is not a known compact currency format type",
+        ) from error
+    number, format = _get_compact_format(number, compact_format, locale, fraction_digits)
+    # Did not find a format, fall back.
+    if format is None or "¤" not in str(format):
+        # find first format that has a currency symbol
+        for magnitude in compact_format['other']:
+            format = compact_format['other'][magnitude].pattern
+            if '¤' not in format:
+                continue
+            # remove characters that are not the currency symbol, 0's or spaces
+            format = re.sub(r'[^0\s\¤]', '', format)
+            # compress adjacent spaces into one
+            format = re.sub(r'(\s)\s+', r'\1', format).strip()
+            break
+    if format is None:
+        raise ValueError('No compact currency format found for the given number and locale.')
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number,
+        locale,
+        currency=currency,
+        currency_digits=False,
+        decimal_quantization=False,
+        numbering_system=numbering_system,
+    )
+
+
+def format_percent(
+    number: float | decimal.Decimal | str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = None,
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return formatted percent value for a specific locale.
+
+    >>> format_percent(0.34, locale='en_US')
+    '34%'
+    >>> format_percent(25.1234, locale='en_US')
+    '2,512%'
+    >>> format_percent(25.1234, locale='sv_SE')
+    '2\\xa0512\\xa0%'
+    >>> format_percent(25.1234, locale='ar_EG', numbering_system='default')
+    '2٬512%'
+
+    The format pattern can also be specified explicitly:
+
+    >>> format_percent(25.1234, '#,##0\\u2030', locale='en_US')
+    '25,123‰'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_percent(23.9876, locale='en_US')
+    '2,399%'
+    >>> format_percent(23.9876, locale='en_US', decimal_quantization=False)
+    '2,398.76%'
+
+    >>> format_percent(229291.1234, locale='pt_BR', group_separator=False)
+    '22929112%'
+
+    >>> format_percent(229291.1234, locale='pt_BR', group_separator=True)
+    '22.929.112%'
+
+    :param number: the percent number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    if not format:
+        format = locale.percent_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number,
+        locale,
+        decimal_quantization=decimal_quantization,
+        group_separator=group_separator,
+        numbering_system=numbering_system,
+    )
+
+
+def format_scientific(
+    number: float | decimal.Decimal | str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = None,
+    decimal_quantization: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return value formatted in scientific notation for a specific locale.
+
+    >>> format_scientific(10000, locale='en_US')
+    '1E4'
+    >>> format_scientific(10000, locale='ar_EG', numbering_system='default')
+    '1أس4'
+
+    The format pattern can also be specified explicitly:
+
+    >>> format_scientific(1234567, '##0.##E00', locale='en_US')
+    '1.23E06'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_scientific(1234.9876, '#.##E0', locale='en_US')
+    '1.23E3'
+    >>> format_scientific(1234.9876, '#.##E0', locale='en_US', decimal_quantization=False)
+    '1.2349876E3'
+
+    :param number: the number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    if not format:
+        format = locale.scientific_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number,
+        locale,
+        decimal_quantization=decimal_quantization,
+        numbering_system=numbering_system,
+    )
+
+
+class NumberFormatError(ValueError):
+    """Exception raised when a string cannot be parsed into a number."""
+
+    def __init__(self, message: str, suggestions: list[str] | None = None) -> None:
+        super().__init__(message)
+        #: a list of properly formatted numbers derived from the invalid input
+        self.suggestions = suggestions
+
+
+SPACE_CHARS = {
+    ' ',  # space
+    '\xa0',  # no-break space
+    '\u202f',  # narrow no-break space
+}
+
+SPACE_CHARS_RE = re.compile('|'.join(SPACE_CHARS))
+
+
+def parse_number(
+    string: str,
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> int:
+    """Parse localized number string into an integer.
+
+    >>> parse_number('1,099', locale='en_US')
+    1099
+    >>> parse_number('1.099', locale='de_DE')
+    1099
+
+    When the given string cannot be parsed, an exception is raised:
+
+    >>> parse_number('1.099,98', locale='de')
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '1.099,98' is not a valid number
+
+    :param string: the string to parse
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :return: the parsed number
+    :raise `NumberFormatError`: if the string can not be converted to a number
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    group_symbol = get_group_symbol(locale, numbering_system=numbering_system)
+
+    if (
+        # if the grouping symbol is a kind of space,
+        group_symbol in SPACE_CHARS
+        # and the string to be parsed does not contain it,
+        and group_symbol not in string
+        # but it does contain any other kind of space instead,
+        and SPACE_CHARS_RE.search(string)
+    ):
+        # ... it's reasonable to assume it is taking the place of the grouping symbol.
+        string = SPACE_CHARS_RE.sub(group_symbol, string)
+
+    try:
+        return int(string.replace(group_symbol, ''))
+    except ValueError as ve:
+        raise NumberFormatError(f"{string!r} is not a valid number") from ve
+
+
+def parse_decimal(
+    string: str,
+    locale: Locale | str | None = None,
+    strict: bool = False,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> decimal.Decimal:
+    """Parse localized decimal string into a decimal.
+
+    >>> parse_decimal('1,099.98', locale='en_US')
+    Decimal('1099.98')
+    >>> parse_decimal('1.099,98', locale='de')
+    Decimal('1099.98')
+    >>> parse_decimal('12 345,123', locale='ru')
+    Decimal('12345.123')
+    >>> parse_decimal('1٬099٫98', locale='ar_EG', numbering_system='default')
+    Decimal('1099.98')
+
+    When the given string cannot be parsed, an exception is raised:
+
+    >>> parse_decimal('2,109,998', locale='de')
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '2,109,998' is not a valid decimal number
+
+    If `strict` is set to `True` and the given string contains a number
+    formatted in an irregular way, an exception is raised:
+
+    >>> parse_decimal('30.00', locale='de', strict=True)
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '30.00' is not a properly formatted decimal number. Did you mean '3.000'? Or maybe '30,00'?
+
+    >>> parse_decimal('0.00', locale='de', strict=True)
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '0.00' is not a properly formatted decimal number. Did you mean '0'?
+
+    :param string: the string to parse
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param strict: controls whether numbers formatted in a weird way are
+                   accepted or rejected
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise NumberFormatError: if the string can not be converted to a
+                              decimal number
+    :raise UnsupportedNumberingSystemError: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    group_symbol = get_group_symbol(locale, numbering_system=numbering_system)
+    decimal_symbol = get_decimal_symbol(locale, numbering_system=numbering_system)
+
+    if not strict and (
+        group_symbol in SPACE_CHARS  # if the grouping symbol is a kind of space,
+        and group_symbol not in string  # and the string to be parsed does not contain it,
+        # but it does contain any other kind of space instead,
+        and SPACE_CHARS_RE.search(string)
+    ):
+        # ... it's reasonable to assume it is taking the place of the grouping symbol.
+        string = SPACE_CHARS_RE.sub(group_symbol, string)
+
+    try:
+        parsed = decimal.Decimal(string.replace(group_symbol, '').replace(decimal_symbol, '.'))
+    except decimal.InvalidOperation as exc:
+        raise NumberFormatError(f"{string!r} is not a valid decimal number") from exc
+    if strict and group_symbol in string:
+        proper = format_decimal(
+            parsed,
+            locale=locale,
+            decimal_quantization=False,
+            numbering_system=numbering_system,
+        )
+        if string != proper and proper != _remove_trailing_zeros_after_decimal(string, decimal_symbol):  # fmt: skip
+            try:
+                parsed_alt = decimal.Decimal(
+                    string.replace(decimal_symbol, '').replace(group_symbol, '.'),
+                )
+            except decimal.InvalidOperation as exc:
+                raise NumberFormatError(
+                    f"{string!r} is not a properly formatted decimal number. "
+                    f"Did you mean {proper!r}?",
+                    suggestions=[proper],
+                ) from exc
+            else:
+                proper_alt = format_decimal(
+                    parsed_alt,
+                    locale=locale,
+                    decimal_quantization=False,
+                    numbering_system=numbering_system,
+                )
+                if proper_alt == proper:
+                    raise NumberFormatError(
+                        f"{string!r} is not a properly formatted decimal number. "
+                        f"Did you mean {proper!r}?",
+                        suggestions=[proper],
+                    )
+                else:
+                    raise NumberFormatError(
+                        f"{string!r} is not a properly formatted decimal number. "
+                        f"Did you mean {proper!r}? Or maybe {proper_alt!r}?",
+                        suggestions=[proper, proper_alt],
+                    )
+    return parsed
+
+
+def _remove_trailing_zeros_after_decimal(string: str, decimal_symbol: str) -> str:
+    """
+    Remove trailing zeros from the decimal part of a numeric string.
+
+    This function takes a string representing a numeric value and a decimal symbol.
+    It removes any trailing zeros that appear after the decimal symbol in the number.
+    If the decimal part becomes empty after removing trailing zeros, the decimal symbol
+    is also removed. If the string does not contain the decimal symbol, it is returned unchanged.
+
+    :param string: The numeric string from which to remove trailing zeros.
+    :type string: str
+    :param decimal_symbol: The symbol used to denote the decimal point.
+    :type decimal_symbol: str
+    :return: The numeric string with trailing zeros removed from its decimal part.
+    :rtype: str
+
+    Example:
+    >>> _remove_trailing_zeros_after_decimal("123.4500", ".")
+    '123.45'
+    >>> _remove_trailing_zeros_after_decimal("100.000", ".")
+    '100'
+    >>> _remove_trailing_zeros_after_decimal("100", ".")
+    '100'
+    """
+    integer_part, _, decimal_part = string.partition(decimal_symbol)
+
+    if decimal_part:
+        decimal_part = decimal_part.rstrip("0")
+        if decimal_part:
+            return integer_part + decimal_symbol + decimal_part
+        return integer_part
+
+    return string
+
+
+_number_pattern_re = re.compile(
+    r"(?P<prefix>(?:[^'0-9@#.,]|'[^']*')*)"
+    r"(?P<number>[0-9@#.,E+]*)"
+    r"(?P<suffix>.*)",
+)
+
+
+def parse_grouping(p: str) -> tuple[int, int]:
+    """Parse primary and secondary digit grouping
+
+    >>> parse_grouping('##')
+    (1000, 1000)
+    >>> parse_grouping('#,###')
+    (3, 3)
+    >>> parse_grouping('#,####,###')
+    (3, 4)
+    """
+    width = len(p)
+    g1 = p.rfind(',')
+    if g1 == -1:
+        return 1000, 1000
+    g1 = width - g1 - 1
+    g2 = p[: -g1 - 1].rfind(',')
+    if g2 == -1:
+        return g1, g1
+    g2 = width - g1 - g2 - 2
+    return g1, g2
+
+
+def parse_pattern(pattern: NumberPattern | str) -> NumberPattern:
+    """Parse number format patterns"""
+    if isinstance(pattern, NumberPattern):
+        return pattern
+
+    def _match_number(pattern):
+        rv = _number_pattern_re.search(pattern)
+        if rv is None:
+            raise ValueError(f"Invalid number pattern {pattern!r}")
+        return rv.groups()
+
+    pos_pattern = pattern
+
+    # Do we have a negative subpattern?
+    if ';' in pattern:
+        pos_pattern, neg_pattern = pattern.split(';', 1)
+        pos_prefix, number, pos_suffix = _match_number(pos_pattern)
+        neg_prefix, _, neg_suffix = _match_number(neg_pattern)
+    else:
+        pos_prefix, number, pos_suffix = _match_number(pos_pattern)
+        neg_prefix = f"-{pos_prefix}"
+        neg_suffix = pos_suffix
+    if 'E' in number:
+        number, exp = number.split('E', 1)
+    else:
+        exp = None
+    if '@' in number and '.' in number and '0' in number:
+        raise ValueError('Significant digit patterns can not contain "@" or "0"')
+    if '.' in number:
+        integer, fraction = number.rsplit('.', 1)
+    else:
+        integer = number
+        fraction = ''
+
+    def parse_precision(p):
+        """Calculate the min and max allowed digits"""
+        min = max = 0
+        for c in p:
+            if c in '@0':
+                min += 1
+                max += 1
+            elif c == '#':
+                max += 1
+            elif c == ',':
+                continue
+            else:
+                break
+        return min, max
+
+    int_prec = parse_precision(integer)
+    frac_prec = parse_precision(fraction)
+    if exp:
+        exp_plus = exp.startswith('+')
+        exp = exp.lstrip('+')
+        exp_prec = parse_precision(exp)
+    else:
+        exp_plus = None
+        exp_prec = None
+    grouping = parse_grouping(integer)
+    return NumberPattern(
+        pattern,
+        (pos_prefix, neg_prefix),
+        (pos_suffix, neg_suffix),
+        grouping,
+        int_prec,
+        frac_prec,
+        exp_prec,
+        exp_plus,
+        number,
+    )
+
+
+class NumberPattern:
+    def __init__(
+        self,
+        pattern: str,
+        prefix: tuple[str, str],
+        suffix: tuple[str, str],
+        grouping: tuple[int, int],
+        int_prec: tuple[int, int],
+        frac_prec: tuple[int, int],
+        exp_prec: tuple[int, int] | None,
+        exp_plus: bool | None,
+        number_pattern: str | None = None,
+    ) -> None:
+        # Metadata of the decomposed parsed pattern.
+        self.pattern = pattern
+        self.prefix = prefix
+        self.suffix = suffix
+        self.number_pattern = number_pattern
+        self.grouping = grouping
+        self.int_prec = int_prec
+        self.frac_prec = frac_prec
+        self.exp_prec = exp_prec
+        self.exp_plus = exp_plus
+        self.scale = self.compute_scale()
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.pattern!r}>"
+
+    def compute_scale(self) -> Literal[0, 2, 3]:
+        """Return the scaling factor to apply to the number before rendering.
+
+        Auto-set to a factor of 2 or 3 if presence of a ``%`` or ``‰`` sign is
+        detected in the prefix or suffix of the pattern. Default is to not mess
+        with the scale at all and keep it to 0.
+        """
+        scale = 0
+        if '%' in ''.join(self.prefix + self.suffix):
+            scale = 2
+        elif '‰' in ''.join(self.prefix + self.suffix):
+            scale = 3
+        return scale
+
+    def scientific_notation_elements(
+        self,
+        value: decimal.Decimal,
+        locale: Locale | str | None,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ) -> tuple[decimal.Decimal, int, str]:
+        """Returns normalized scientific notation components of a value."""
+        # Normalize value to only have one lead digit.
+        exp = value.adjusted()
+        value = value * get_decimal_quantum(exp)
+        assert value.adjusted() == 0
+
+        # Shift exponent and value by the minimum number of leading digits
+        # imposed by the rendering pattern. And always make that number
+        # greater or equal to 1.
+        lead_shift = max([1, min(self.int_prec)]) - 1
+        exp = exp - lead_shift
+        value = value * get_decimal_quantum(-lead_shift)
+
+        # Get exponent sign symbol.
+        exp_sign = ''
+        if exp < 0:
+            exp_sign = get_minus_sign_symbol(locale, numbering_system=numbering_system)
+        elif self.exp_plus:
+            exp_sign = get_plus_sign_symbol(locale, numbering_system=numbering_system)
+
+        # Normalize exponent value now that we have the sign.
+        exp = abs(exp)
+
+        return value, exp, exp_sign
+
+    def apply(
+        self,
+        value: float | decimal.Decimal | str,
+        locale: Locale | str | None,
+        currency: str | None = None,
+        currency_digits: bool = True,
+        decimal_quantization: bool = True,
+        force_frac: tuple[int, int] | None = None,
+        group_separator: bool = True,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ):
+        """Renders into a string a number following the defined pattern.
+
+        Forced decimal quantization is active by default so we'll produce a
+        number string that is strictly following CLDR pattern definitions.
+
+        :param value: The value to format. If this is not a Decimal object,
+                      it will be cast to one.
+        :type value: decimal.Decimal|float|int
+        :param locale: The locale to use for formatting.
+        :type locale: str|babel.core.Locale
+        :param currency: Which currency, if any, to format as.
+        :type currency: str|None
+        :param currency_digits: Whether or not to use the currency's precision.
+                                If false, the pattern's precision is used.
+        :type currency_digits: bool
+        :param decimal_quantization: Whether decimal numbers should be forcibly
+                                     quantized to produce a formatted output
+                                     strictly matching the CLDR definition for
+                                     the locale.
+        :type decimal_quantization: bool
+        :param force_frac: DEPRECATED - a forced override for `self.frac_prec`
+                           for a single formatting invocation.
+        :param group_separator: Whether to use the locale's number group separator.
+        :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                                 The special value "default" will use the default numbering system of the locale.
+        :return: Formatted decimal string.
+        :rtype: str
+        :raise UnsupportedNumberingSystemError: If the numbering system is not supported by the locale.
+        """
+        if not isinstance(value, decimal.Decimal):
+            value = decimal.Decimal(str(value))
+
+        value = value.scaleb(self.scale)
+
+        # Separate the absolute value from its sign.
+        is_negative = int(value.is_signed())
+        value = abs(value).normalize()
+
+        # Prepare scientific notation metadata.
+        if self.exp_prec:
+            value, exp, exp_sign = self.scientific_notation_elements(
+                value,
+                locale,
+                numbering_system=numbering_system,
+            )
+
+        # Adjust the precision of the fractional part and force it to the
+        # currency's if necessary.
+        if force_frac:
+            # TODO (3.x?): Remove this parameter
+            warnings.warn(
+                'The force_frac parameter to NumberPattern.apply() is deprecated.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            frac_prec = force_frac
+        elif currency and currency_digits:
+            frac_prec = (get_currency_precision(currency),) * 2
+        else:
+            frac_prec = self.frac_prec
+
+        # Bump decimal precision to the natural precision of the number if it
+        # exceeds the one we're about to use. This adaptative precision is only
+        # triggered if the decimal quantization is disabled or if a scientific
+        # notation pattern has a missing mandatory fractional part (as in the
+        # default '#E0' pattern). This special case has been extensively
+        # discussed at https://github.com/python-babel/babel/pull/494#issuecomment-307649969 .
+        if not decimal_quantization or (self.exp_prec and frac_prec == (0, 0)):
+            frac_prec = (frac_prec[0], max([frac_prec[1], get_decimal_precision(value)]))
+
+        # Render scientific notation.
+        if self.exp_prec:
+            number = ''.join([
+                self._quantize_value(value, locale, frac_prec, group_separator, numbering_system=numbering_system),
+                get_exponential_symbol(locale, numbering_system=numbering_system),
+                exp_sign,  # type: ignore  # exp_sign is always defined here
+                self._format_int(str(exp), self.exp_prec[0], self.exp_prec[1], locale, numbering_system=numbering_system),  # type: ignore  # exp is always defined here
+            ])  # fmt: skip
+
+        # Is it a significant digits pattern?
+        elif '@' in self.pattern:
+            text = self._format_significant(value, self.int_prec[0], self.int_prec[1])
+            a, sep, b = text.partition(".")
+            number = self._format_int(a, 0, 1000, locale, numbering_system=numbering_system)
+            if sep:
+                number += get_decimal_symbol(locale, numbering_system=numbering_system) + b
+
+        # A normal number pattern.
+        else:
+            number = self._quantize_value(
+                value,
+                locale,
+                frac_prec,
+                group_separator,
+                numbering_system=numbering_system,
+            )
+
+        retval = ''.join(
+            (
+                self.prefix[is_negative],
+                number if self.number_pattern != '' else '',
+                self.suffix[is_negative],
+            ),
+        )
+
+        if '¤' in retval and currency is not None:
+            retval = retval.replace('¤¤¤', get_currency_name(currency, value, locale))
+            retval = retval.replace('¤¤', currency.upper())
+            retval = retval.replace('¤', get_currency_symbol(currency, locale))
+
+        # remove single quotes around text, except for doubled single quotes
+        # which are replaced with a single quote
+        retval = re.sub(r"'([^']*)'", lambda m: m.group(1) or "'", retval)
+
+        return retval
+
+    #
+    # This is one tricky piece of code.  The idea is to rely as much as possible
+    # on the decimal module to minimize the amount of code.
+    #
+    # Conceptually, the implementation of this method can be summarized in the
+    # following steps:
+    #
+    #   - Move or shift the decimal point (i.e. the exponent) so the maximum
+    #     amount of significant digits fall into the integer part (i.e. to the
+    #     left of the decimal point)
+    #
+    #   - Round the number to the nearest integer, discarding all the fractional
+    #     part which contained extra digits to be eliminated
+    #
+    #   - Convert the rounded integer to a string, that will contain the final
+    #     sequence of significant digits already trimmed to the maximum
+    #
+    #   - Restore the original position of the decimal point, potentially
+    #     padding with zeroes on either side
+    #
+    def _format_significant(self, value: decimal.Decimal, minimum: int, maximum: int) -> str:
+        exp = value.adjusted()
+        scale = maximum - 1 - exp
+        digits = str(value.scaleb(scale).quantize(decimal.Decimal(1)))
+        if scale <= 0:
+            result = digits + '0' * -scale
+        else:
+            intpart = digits[:-scale]
+            i = len(intpart)
+            j = i + max(minimum - i, 0)
+            result = "{intpart}.{pad:0<{fill}}{fracpart}{fracextra}".format(
+                intpart=intpart or '0',
+                pad='',
+                fill=-min(exp + 1, 0),
+                fracpart=digits[i:j],
+                fracextra=digits[j:].rstrip('0'),
+            ).rstrip('.')
+        return result
+
+    def _format_int(
+        self,
+        value: str,
+        min: int,
+        max: int,
+        locale: Locale | str | None,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        width = len(value)
+        if width < min:
+            value = '0' * (min - width) + value
+        gsize = self.grouping[0]
+        ret = ''
+        symbol = get_group_symbol(locale, numbering_system=numbering_system)
+        while len(value) > gsize:
+            ret = symbol + value[-gsize:] + ret
+            value = value[:-gsize]
+            gsize = self.grouping[1]
+        return value + ret
+
+    def _quantize_value(
+        self,
+        value: decimal.Decimal,
+        locale: Locale | str | None,
+        frac_prec: tuple[int, int],
+        group_separator: bool,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        # If the number is +/-Infinity, we can't quantize it
+        if value.is_infinite():
+            return get_infinity_symbol(locale, numbering_system=numbering_system)
+        quantum = get_decimal_quantum(frac_prec[1])
+        rounded = value.quantize(quantum)
+        a, sep, b = f"{rounded:f}".partition(".")
+        integer_part = a
+        if group_separator:
+            integer_part = self._format_int(
+                a,
+                self.int_prec[0],
+                self.int_prec[1],
+                locale,
+                numbering_system=numbering_system,
+            )
+        number = integer_part + self._format_frac(
+            b or '0',
+            locale=locale,
+            force_frac=frac_prec,
+            numbering_system=numbering_system,
+        )
+        return number
+
+    def _format_frac(
+        self,
+        value: str,
+        locale: Locale | str | None,
+        force_frac: tuple[int, int] | None = None,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        min, max = force_frac or self.frac_prec
+        if len(value) < min:
+            value += '0' * (min - len(value))
+        if max == 0 or (min == 0 and int(value) == 0):
+            return ''
+        while len(value) > min and value[-1] == '0':
+            value = value[:-1]
+        return get_decimal_symbol(locale, numbering_system=numbering_system) + value

micromamba_root/Lib/site-packages/babel/plural.py

@@ -0,0 +1,652 @@
+"""
+babel.numbers
+~~~~~~~~~~~~~
+
+CLDR Plural support.  See UTS #35.
+
+:copyright: (c) 2013-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import decimal
+import re
+from collections.abc import Iterable, Mapping
+from typing import Any, Callable, Literal
+
+_plural_tags = ('zero', 'one', 'two', 'few', 'many', 'other')
+_fallback_tag = 'other'
+
+
+def extract_operands(
+    source: float | decimal.Decimal,
+) -> tuple[decimal.Decimal | int, int, int, int, int, int, Literal[0], Literal[0]]:
+    """Extract operands from a decimal, a float or an int, according to `CLDR rules`_.
+
+    The result is an 8-tuple (n, i, v, w, f, t, c, e), where those symbols are as follows:
+
+    ====== ===============================================================
+    Symbol Value
+    ------ ---------------------------------------------------------------
+    n      absolute value of the source number (integer and decimals).
+    i      integer digits of n.
+    v      number of visible fraction digits in n, with trailing zeros.
+    w      number of visible fraction digits in n, without trailing zeros.
+    f      visible fractional digits in n, with trailing zeros.
+    t      visible fractional digits in n, without trailing zeros.
+    c      compact decimal exponent value: exponent of the power of 10 used in compact decimal formatting.
+    e      currently, synonym for ‘c’. however, may be redefined in the future.
+    ====== ===============================================================
+
+    .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-61/tr35-numbers.html#Operands
+
+    :param source: A real number
+    :type source: int|float|decimal.Decimal
+    :return: A n-i-v-w-f-t-c-e tuple
+    :rtype: tuple[decimal.Decimal, int, int, int, int, int, int, int]
+    """
+    n = abs(source)
+    i = int(n)
+    if isinstance(n, float):
+        if i == n:
+            n = i
+        else:
+            # Cast the `float` to a number via the string representation.
+            # This is required for Python 2.6 anyway (it will straight out fail to
+            # do the conversion otherwise), and it's highly unlikely that the user
+            # actually wants the lossless conversion behavior (quoting the Python
+            # documentation):
+            # > If value is a float, the binary floating point value is losslessly
+            # > converted to its exact decimal equivalent.
+            # > This conversion can often require 53 or more digits of precision.
+            # Should the user want that behavior, they can simply pass in a pre-
+            # converted `Decimal` instance of desired accuracy.
+            n = decimal.Decimal(str(n))
+
+    if isinstance(n, decimal.Decimal):
+        dec_tuple = n.as_tuple()
+        exp = dec_tuple.exponent
+        fraction_digits = dec_tuple.digits[exp:] if exp < 0 else ()
+        trailing = ''.join(str(d) for d in fraction_digits)
+        no_trailing = trailing.rstrip('0')
+        v = len(trailing)
+        w = len(no_trailing)
+        f = int(trailing or 0)
+        t = int(no_trailing or 0)
+    else:
+        v = w = f = t = 0
+    c = e = 0  # TODO: c and e are not supported
+    return n, i, v, w, f, t, c, e
+
+
+class PluralRule:
+    """Represents a set of language pluralization rules.  The constructor
+    accepts a list of (tag, expr) tuples or a dict of `CLDR rules`_. The
+    resulting object is callable and accepts one parameter with a positive or
+    negative number (both integer and float) for the number that indicates the
+    plural form for a string and returns the tag for the format:
+
+    >>> rule = PluralRule({'one': 'n is 1'})
+    >>> rule(1)
+    'one'
+    >>> rule(2)
+    'other'
+
+    Currently the CLDR defines these tags: zero, one, two, few, many and
+    other where other is an implicit default.  Rules should be mutually
+    exclusive; for a given numeric value, only one rule should apply (i.e.
+    the condition should only be true for one of the plural rule elements.
+
+    .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-33/tr35-numbers.html#Language_Plural_Rules
+    """
+
+    __slots__ = ('abstract', '_func')
+
+    def __init__(self, rules: Mapping[str, str] | Iterable[tuple[str, str]]) -> None:
+        """Initialize the rule instance.
+
+        :param rules: a list of ``(tag, expr)``) tuples with the rules
+                      conforming to UTS #35 or a dict with the tags as keys
+                      and expressions as values.
+        :raise RuleError: if the expression is malformed
+        """
+        if isinstance(rules, Mapping):
+            rules = rules.items()
+        found = set()
+        self.abstract: list[tuple[str, Any]] = []
+        for key, expr in sorted(rules):
+            if key not in _plural_tags:
+                raise ValueError(f"unknown tag {key!r}")
+            elif key in found:
+                raise ValueError(f"tag {key!r} defined twice")
+            found.add(key)
+            ast = _Parser(expr).ast
+            if ast:
+                self.abstract.append((key, ast))
+
+    def __repr__(self) -> str:
+        rules = self.rules
+        args = ", ".join(f"{tag}: {rules[tag]}" for tag in _plural_tags if tag in rules)
+        return f"<{type(self).__name__} {args!r}>"
+
+    @classmethod
+    def parse(
+        cls,
+        rules: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule,
+    ) -> PluralRule:
+        """Create a `PluralRule` instance for the given rules.  If the rules
+        are a `PluralRule` object, that object is returned.
+
+        :param rules: the rules as list or dict, or a `PluralRule` object
+        :raise RuleError: if the expression is malformed
+        """
+        if isinstance(rules, PluralRule):
+            return rules
+        return cls(rules)
+
+    @property
+    def rules(self) -> Mapping[str, str]:
+        """The `PluralRule` as a dict of unicode plural rules.
+
+        >>> rule = PluralRule({'one': 'n is 1'})
+        >>> rule.rules
+        {'one': 'n is 1'}
+        """
+        _compile = _UnicodeCompiler().compile
+        return {tag: _compile(ast) for tag, ast in self.abstract}
+
+    @property
+    def tags(self) -> frozenset[str]:
+        """A set of explicitly defined tags in this rule.  The implicit default
+        ``'other'`` rules is not part of this set unless there is an explicit
+        rule for it.
+        """
+        return frozenset(i[0] for i in self.abstract)
+
+    def __getstate__(self) -> list[tuple[str, Any]]:
+        return self.abstract
+
+    def __setstate__(self, abstract: list[tuple[str, Any]]) -> None:
+        self.abstract = abstract
+
+    def __call__(self, n: float | decimal.Decimal) -> str:
+        if not hasattr(self, '_func'):
+            self._func = to_python(self)
+        return self._func(n)
+
+
+def to_javascript(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> str:
+    """Convert a list/dict of rules or a `PluralRule` object into a JavaScript
+    function.  This function depends on no external library:
+
+    >>> to_javascript({'one': 'n is 1'})
+    "(function(n) { return (n == 1) ? 'one' : 'other'; })"
+
+    Implementation detail: The function generated will probably evaluate
+    expressions involved into range operations multiple times.  This has the
+    advantage that external helper functions are not required and is not a
+    big performance hit for these simple calculations.
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    to_js = _JavaScriptCompiler().compile
+    result = ['(function(n) { return ']
+    for tag, ast in PluralRule.parse(rule).abstract:
+        result.append(f"{to_js(ast)} ? {tag!r} : ")
+    result.append('%r; })' % _fallback_tag)
+    return ''.join(result)
+
+
+def to_python(
+    rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule,
+) -> Callable[[float | decimal.Decimal], str]:
+    """Convert a list/dict of rules or a `PluralRule` object into a regular
+    Python function.  This is useful in situations where you need a real
+    function and don't are about the actual rule object:
+
+    >>> func = to_python({'one': 'n is 1', 'few': 'n in 2..4'})
+    >>> func(1)
+    'one'
+    >>> func(3)
+    'few'
+    >>> func = to_python({'one': 'n in 1,11', 'few': 'n in 3..10,13..19'})
+    >>> func(11)
+    'one'
+    >>> func(15)
+    'few'
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    namespace = {
+        'IN': in_range_list,
+        'WITHIN': within_range_list,
+        'MOD': cldr_modulo,
+        'extract_operands': extract_operands,
+    }
+    to_python_func = _PythonCompiler().compile
+    result = [
+        'def evaluate(n):',
+        ' n, i, v, w, f, t, c, e = extract_operands(n)',
+    ]
+    for tag, ast in PluralRule.parse(rule).abstract:
+        # the str() call is to coerce the tag to the native string.  It's
+        # a limited ascii restricted set of tags anyways so that is fine.
+        result.append(f" if ({to_python_func(ast)}): return {str(tag)!r}")
+    result.append(f" return {_fallback_tag!r}")
+    code = compile('\n'.join(result), '<rule>', 'exec')
+    eval(code, namespace)
+    return namespace['evaluate']
+
+
+def to_gettext(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> str:
+    """The plural rule as gettext expression.  The gettext expression is
+    technically limited to integers and returns indices rather than tags.
+
+    >>> to_gettext({'one': 'n is 1', 'two': 'n is 2'})
+    'nplurals=3; plural=((n == 1) ? 0 : (n == 2) ? 1 : 2);'
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    rule = PluralRule.parse(rule)
+
+    used_tags = rule.tags | {_fallback_tag}
+    _compile = _GettextCompiler().compile
+    _get_index = [tag for tag in _plural_tags if tag in used_tags].index
+
+    result = [f"nplurals={len(used_tags)}; plural=("]
+    for tag, ast in rule.abstract:
+        result.append(f"{_compile(ast)} ? {_get_index(tag)} : ")
+    result.append(f"{_get_index(_fallback_tag)});")
+    return ''.join(result)
+
+
+def in_range_list(
+    num: float | decimal.Decimal,
+    range_list: Iterable[Iterable[float | decimal.Decimal]],
+) -> bool:
+    """Integer range list test.  This is the callback for the "in" operator
+    of the UTS #35 pluralization rule language:
+
+    >>> in_range_list(1, [(1, 3)])
+    True
+    >>> in_range_list(3, [(1, 3)])
+    True
+    >>> in_range_list(3, [(1, 3), (5, 8)])
+    True
+    >>> in_range_list(1.2, [(1, 4)])
+    False
+    >>> in_range_list(10, [(1, 4)])
+    False
+    >>> in_range_list(10, [(1, 4), (6, 8)])
+    False
+    """
+    return num == int(num) and within_range_list(num, range_list)
+
+
+def within_range_list(
+    num: float | decimal.Decimal,
+    range_list: Iterable[Iterable[float | decimal.Decimal]],
+) -> bool:
+    """Float range test.  This is the callback for the "within" operator
+    of the UTS #35 pluralization rule language:
+
+    >>> within_range_list(1, [(1, 3)])
+    True
+    >>> within_range_list(1.0, [(1, 3)])
+    True
+    >>> within_range_list(1.2, [(1, 4)])
+    True
+    >>> within_range_list(8.8, [(1, 4), (7, 15)])
+    True
+    >>> within_range_list(10, [(1, 4)])
+    False
+    >>> within_range_list(10.5, [(1, 4), (20, 30)])
+    False
+    """
+    return any(min_ <= num <= max_ for min_, max_ in range_list)
+
+
+def cldr_modulo(a: float, b: float) -> float:
+    """Javaish modulo.  This modulo operator returns the value with the sign
+    of the dividend rather than the divisor like Python does:
+
+    >>> cldr_modulo(-3, 5)
+    -3
+    >>> cldr_modulo(-3, -5)
+    -3
+    >>> cldr_modulo(3, 5)
+    3
+    """
+    reverse = 0
+    if a < 0:
+        a *= -1
+        reverse = 1
+    if b < 0:
+        b *= -1
+    rv = a % b
+    if reverse:
+        rv *= -1
+    return rv
+
+
+class RuleError(Exception):
+    """Raised if a rule is malformed."""
+
+
+_VARS = {
+    'n',  # absolute value of the source number.
+    'i',  # integer digits of n.
+    'v',  # number of visible fraction digits in n, with trailing zeros.*
+    'w',  # number of visible fraction digits in n, without trailing zeros.*
+    'f',  # visible fraction digits in n, with trailing zeros.*
+    't',  # visible fraction digits in n, without trailing zeros.*
+    'c',  # compact decimal exponent value: exponent of the power of 10 used in compact decimal formatting.
+    'e',  # currently, synonym for `c`. however, may be redefined in the future.
+}
+
+_RULES: list[tuple[str | None, re.Pattern[str]]] = [
+    (None, re.compile(r'\s+', re.UNICODE)),
+    ('word', re.compile(rf'\b(and|or|is|(?:with)?in|not|mod|[{"".join(_VARS)}])\b')),
+    ('value', re.compile(r'\d+')),
+    ('symbol', re.compile(r'%|,|!=|=')),
+    ('ellipsis', re.compile(r'\.{2,3}|\u2026', re.UNICODE)),  # U+2026: ELLIPSIS
+]
+
+
+def tokenize_rule(s: str) -> list[tuple[str, str]]:
+    s = s.split('@')[0]
+    result: list[tuple[str, str]] = []
+    pos = 0
+    end = len(s)
+    while pos < end:
+        for tok, rule in _RULES:
+            match = rule.match(s, pos)
+            if match is not None:
+                pos = match.end()
+                if tok:
+                    result.append((tok, match.group()))
+                break
+        else:
+            raise RuleError(f"malformed CLDR pluralization rule.  Got unexpected {s[pos]!r}")
+    return result[::-1]
+
+
+def test_next_token(
+    tokens: list[tuple[str, str]],
+    type_: str,
+    value: str | None = None,
+) -> list[tuple[str, str]] | bool:
+    return tokens and tokens[-1][0] == type_ and (value is None or tokens[-1][1] == value)
+
+
+def skip_token(tokens: list[tuple[str, str]], type_: str, value: str | None = None):
+    if test_next_token(tokens, type_, value):
+        return tokens.pop()
+
+
+def value_node(value: int) -> tuple[Literal['value'], tuple[int]]:
+    return 'value', (value,)
+
+
+def ident_node(name: str) -> tuple[str, tuple[()]]:
+    return name, ()
+
+
+def range_list_node(
+    range_list: Iterable[Iterable[float | decimal.Decimal]],
+) -> tuple[Literal['range_list'], Iterable[Iterable[float | decimal.Decimal]]]:
+    return 'range_list', range_list
+
+
+def negate(rv: tuple[Any, ...]) -> tuple[Literal['not'], tuple[tuple[Any, ...]]]:
+    return 'not', (rv,)
+
+
+class _Parser:
+    """Internal parser.  This class can translate a single rule into an abstract
+    tree of tuples. It implements the following grammar::
+
+        condition     = and_condition ('or' and_condition)*
+                        ('@integer' samples)?
+                        ('@decimal' samples)?
+        and_condition = relation ('and' relation)*
+        relation      = is_relation | in_relation | within_relation
+        is_relation   = expr 'is' ('not')? value
+        in_relation   = expr (('not')? 'in' | '=' | '!=') range_list
+        within_relation = expr ('not')? 'within' range_list
+        expr          = operand (('mod' | '%') value)?
+        operand       = 'n' | 'i' | 'f' | 't' | 'v' | 'w'
+        range_list    = (range | value) (',' range_list)*
+        value         = digit+
+        digit         = 0|1|2|3|4|5|6|7|8|9
+        range         = value'..'value
+        samples       = sampleRange (',' sampleRange)* (',' ('…'|'...'))?
+        sampleRange   = decimalValue '~' decimalValue
+        decimalValue  = value ('.' value)?
+
+    - Whitespace can occur between or around any of the above tokens.
+    - Rules should be mutually exclusive; for a given numeric value, only one
+      rule should apply (i.e. the condition should only be true for one of
+      the plural rule elements).
+    - The in and within relations can take comma-separated lists, such as:
+      'n in 3,5,7..15'.
+    - Samples are ignored.
+
+    The translator parses the expression on instantiation into an attribute
+    called `ast`.
+    """
+
+    def __init__(self, string):
+        self.tokens = tokenize_rule(string)
+        if not self.tokens:
+            # If the pattern is only samples, it's entirely possible
+            # no stream of tokens whatsoever is generated.
+            self.ast = None
+            return
+        self.ast = self.condition()
+        if self.tokens:
+            raise RuleError(f"Expected end of rule, got {self.tokens[-1][1]!r}")
+
+    def expect(self, type_, value=None, term=None):
+        token = skip_token(self.tokens, type_, value)
+        if token is not None:
+            return token
+        if term is None:
+            term = repr(value is None and type_ or value)
+        if not self.tokens:
+            raise RuleError(f"expected {term} but end of rule reached")
+        raise RuleError(f"expected {term} but got {self.tokens[-1][1]!r}")
+
+    def condition(self):
+        op = self.and_condition()
+        while skip_token(self.tokens, 'word', 'or'):
+            op = 'or', (op, self.and_condition())
+        return op
+
+    def and_condition(self):
+        op = self.relation()
+        while skip_token(self.tokens, 'word', 'and'):
+            op = 'and', (op, self.relation())
+        return op
+
+    def relation(self):
+        left = self.expr()
+        if skip_token(self.tokens, 'word', 'is'):
+            op = 'isnot' if skip_token(self.tokens, 'word', 'not') else 'is'
+            return op, (left, self.value())
+        negated = skip_token(self.tokens, 'word', 'not')
+        method = 'in'
+        if skip_token(self.tokens, 'word', 'within'):
+            method = 'within'
+        else:
+            if not skip_token(self.tokens, 'word', 'in'):
+                if negated:
+                    raise RuleError('Cannot negate operator based rules.')
+                return self.newfangled_relation(left)
+        rv = 'relation', (method, left, self.range_list())
+        return negate(rv) if negated else rv
+
+    def newfangled_relation(self, left):
+        if skip_token(self.tokens, 'symbol', '='):
+            negated = False
+        elif skip_token(self.tokens, 'symbol', '!='):
+            negated = True
+        else:
+            raise RuleError('Expected "=" or "!=" or legacy relation')
+        rv = 'relation', ('in', left, self.range_list())
+        return negate(rv) if negated else rv
+
+    def range_or_value(self):
+        left = self.value()
+        if skip_token(self.tokens, 'ellipsis'):
+            return left, self.value()
+        else:
+            return left, left
+
+    def range_list(self):
+        range_list = [self.range_or_value()]
+        while skip_token(self.tokens, 'symbol', ','):
+            range_list.append(self.range_or_value())
+        return range_list_node(range_list)
+
+    def expr(self):
+        word = skip_token(self.tokens, 'word')
+        if word is None or word[1] not in _VARS:
+            raise RuleError('Expected identifier variable')
+        name = word[1]
+        if skip_token(self.tokens, 'word', 'mod'):
+            return 'mod', ((name, ()), self.value())
+        elif skip_token(self.tokens, 'symbol', '%'):
+            return 'mod', ((name, ()), self.value())
+        return ident_node(name)
+
+    def value(self):
+        return value_node(int(self.expect('value')[1]))
+
+
+def _binary_compiler(tmpl):
+    """Compiler factory for the `_Compiler`."""
+    return lambda self, left, right: tmpl % (self.compile(left), self.compile(right))
+
+
+def _unary_compiler(tmpl):
+    """Compiler factory for the `_Compiler`."""
+    return lambda self, x: tmpl % self.compile(x)
+
+
+compile_zero = lambda x: '0'
+
+
+class _Compiler:
+    """The compilers are able to transform the expressions into multiple
+    output formats.
+    """
+
+    def compile(self, arg):
+        op, args = arg
+        return getattr(self, f"compile_{op}")(*args)
+
+    compile_n = lambda x: 'n'
+    compile_i = lambda x: 'i'
+    compile_v = lambda x: 'v'
+    compile_w = lambda x: 'w'
+    compile_f = lambda x: 'f'
+    compile_t = lambda x: 't'
+    compile_c = lambda x: 'c'
+    compile_e = lambda x: 'e'
+    compile_value = lambda x, v: str(v)
+    compile_and = _binary_compiler('(%s && %s)')
+    compile_or = _binary_compiler('(%s || %s)')
+    compile_not = _unary_compiler('(!%s)')
+    compile_mod = _binary_compiler('(%s %% %s)')
+    compile_is = _binary_compiler('(%s == %s)')
+    compile_isnot = _binary_compiler('(%s != %s)')
+
+    def compile_relation(self, method, expr, range_list):
+        raise NotImplementedError()
+
+
+class _PythonCompiler(_Compiler):
+    """Compiles an expression to Python."""
+
+    compile_and = _binary_compiler('(%s and %s)')
+    compile_or = _binary_compiler('(%s or %s)')
+    compile_not = _unary_compiler('(not %s)')
+    compile_mod = _binary_compiler('MOD(%s, %s)')
+
+    def compile_relation(self, method, expr, range_list):
+        ranges = ",".join(
+            f"({self.compile(a)}, {self.compile(b)})" for (a, b) in range_list[1]
+        )
+        return f"{method.upper()}({self.compile(expr)}, [{ranges}])"
+
+
+class _GettextCompiler(_Compiler):
+    """Compile into a gettext plural expression."""
+
+    compile_i = _Compiler.compile_n
+    compile_v = compile_zero
+    compile_w = compile_zero
+    compile_f = compile_zero
+    compile_t = compile_zero
+
+    def compile_relation(self, method, expr, range_list):
+        rv = []
+        expr = self.compile(expr)
+        for item in range_list[1]:
+            if item[0] == item[1]:
+                rv.append(f"({expr} == {self.compile(item[0])})")
+            else:
+                min = self.compile(item[0])
+                max = self.compile(item[1])
+                rv.append(f"({expr} >= {min} && {expr} <= {max})")
+        return f"({' || '.join(rv)})"
+
+
+class _JavaScriptCompiler(_GettextCompiler):
+    """Compiles the expression to plain of JavaScript."""
+
+    # XXX: presently javascript does not support any of the
+    # fraction support and basically only deals with integers.
+    compile_i = lambda x: 'parseInt(n, 10)'
+    compile_v = compile_zero
+    compile_w = compile_zero
+    compile_f = compile_zero
+    compile_t = compile_zero
+
+    def compile_relation(self, method, expr, range_list):
+        code = _GettextCompiler.compile_relation(self, method, expr, range_list)
+        if method == 'in':
+            expr = self.compile(expr)
+            code = f"(parseInt({expr}, 10) == {expr} && {code})"
+        return code
+
+
+class _UnicodeCompiler(_Compiler):
+    """Returns a unicode pluralization rule again."""
+
+    # XXX: this currently spits out the old syntax instead of the new
+    # one.  We can change that, but it will break a whole bunch of stuff
+    # for users I suppose.
+
+    compile_is = _binary_compiler('%s is %s')
+    compile_isnot = _binary_compiler('%s is not %s')
+    compile_and = _binary_compiler('%s and %s')
+    compile_or = _binary_compiler('%s or %s')
+    compile_mod = _binary_compiler('%s mod %s')
+
+    def compile_not(self, relation):
+        return self.compile_relation(*relation[1], negated=True)
+
+    def compile_relation(self, method, expr, range_list, negated=False):
+        ranges = []
+        for item in range_list[1]:
+            if item[0] == item[1]:
+                ranges.append(self.compile(item[0]))
+            else:
+                ranges.append(f"{self.compile(item[0])}..{self.compile(item[1])}")
+        return f"{self.compile(expr)}{' not' if negated else ''} {method} {','.join(ranges)}"

micromamba_root/Lib/site-packages/babel/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. This package uses inline types.

micromamba_root/Lib/site-packages/babel/support.py

@@ -0,0 +1,796 @@
+"""
+babel.support
+~~~~~~~~~~~~~
+
+Several classes and functions that help with integrating and using Babel
+in applications.
+
+.. note: the code in this module is not used by Babel itself
+
+:copyright: (c) 2013-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import gettext
+import locale
+import os
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal
+
+from babel.core import Locale
+from babel.dates import format_date, format_datetime, format_time, format_timedelta
+from babel.numbers import (
+    format_compact_currency,
+    format_compact_decimal,
+    format_currency,
+    format_decimal,
+    format_percent,
+    format_scientific,
+)
+
+if TYPE_CHECKING:
+    import datetime as _datetime
+    from decimal import Decimal
+
+    from babel.dates import _PredefinedTimeFormat
+
+
+class Format:
+    """Wrapper class providing the various date and number formatting functions
+    bound to a specific locale and time-zone.
+
+    >>> from babel.util import UTC
+    >>> from datetime import date
+    >>> fmt = Format('en_US', UTC)
+    >>> fmt.date(date(2007, 4, 1))
+    'Apr 1, 2007'
+    >>> fmt.decimal(1.2345)
+    '1.234'
+    """
+
+    def __init__(
+        self,
+        locale: Locale | str,
+        tzinfo: _datetime.tzinfo | None = None,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ) -> None:
+        """Initialize the formatter.
+
+        :param locale: the locale identifier or `Locale` instance
+        :param tzinfo: the time-zone info (a `tzinfo` instance or `None`)
+        :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                                 The special value "default" will use the default numbering system of the locale.
+        """
+        self.locale = Locale.parse(locale)
+        self.tzinfo = tzinfo
+        self.numbering_system = numbering_system
+
+    def date(
+        self,
+        date: _datetime.date | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a date formatted according to the given pattern.
+
+        >>> from datetime import date
+        >>> fmt = Format('en_US')
+        >>> fmt.date(date(2007, 4, 1))
+        'Apr 1, 2007'
+        """
+        return format_date(date, format, locale=self.locale)
+
+    def datetime(
+        self,
+        datetime: _datetime.date | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a date and time formatted according to the given pattern.
+
+        >>> from datetime import datetime
+        >>> from babel.dates import get_timezone
+        >>> fmt = Format('en_US', tzinfo=get_timezone('US/Eastern'))
+        >>> fmt.datetime(datetime(2007, 4, 1, 15, 30))
+        'Apr 1, 2007, 11:30:00\\u202fAM'
+        """
+        return format_datetime(datetime, format, tzinfo=self.tzinfo, locale=self.locale)
+
+    def time(
+        self,
+        time: _datetime.time | _datetime.datetime | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a time formatted according to the given pattern.
+
+        >>> from datetime import datetime
+        >>> from babel.dates import get_timezone
+        >>> fmt = Format('en_US', tzinfo=get_timezone('US/Eastern'))
+        >>> fmt.time(datetime(2007, 4, 1, 15, 30))
+        '11:30:00\\u202fAM'
+        """
+        return format_time(time, format, tzinfo=self.tzinfo, locale=self.locale)
+
+    def timedelta(
+        self,
+        delta: _datetime.timedelta | int,
+        granularity: Literal[
+            "year",
+            "month",
+            "week",
+            "day",
+            "hour",
+            "minute",
+            "second",
+        ] = "second",
+        threshold: float = 0.85,
+        format: Literal["narrow", "short", "medium", "long"] = "long",
+        add_direction: bool = False,
+    ) -> str:
+        """Return a time delta according to the rules of the given locale.
+
+        >>> from datetime import timedelta
+        >>> fmt = Format('en_US')
+        >>> fmt.timedelta(timedelta(weeks=11))
+        '3 months'
+        """
+        return format_timedelta(
+            delta,
+            granularity=granularity,
+            threshold=threshold,
+            format=format,
+            add_direction=add_direction,
+            locale=self.locale,
+        )
+
+    def number(self, number: float | Decimal | str) -> str:
+        """Return an integer number formatted for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.number(1099)
+        '1,099'
+        """
+        return format_decimal(
+            number,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+    def decimal(self, number: float | Decimal | str, format: str | None = None) -> str:
+        """Return a decimal number formatted for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.decimal(1.2345)
+        '1.234'
+        """
+        return format_decimal(
+            number,
+            format,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+    def compact_decimal(
+        self,
+        number: float | Decimal | str,
+        format_type: Literal['short', 'long'] = 'short',
+        fraction_digits: int = 0,
+    ) -> str:
+        """Return a number formatted in compact form for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.compact_decimal(123456789)
+        '123M'
+        >>> fmt.compact_decimal(1234567, format_type='long', fraction_digits=2)
+        '1.23 million'
+        """
+        return format_compact_decimal(
+            number,
+            format_type=format_type,
+            fraction_digits=fraction_digits,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+    def currency(self, number: float | Decimal | str, currency: str) -> str:
+        """Return a number in the given currency formatted for the locale."""
+        return format_currency(
+            number,
+            currency,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+    def compact_currency(
+        self,
+        number: float | Decimal | str,
+        currency: str,
+        format_type: Literal['short'] = 'short',
+        fraction_digits: int = 0,
+    ) -> str:
+        """Return a number in the given currency formatted for the locale
+        using the compact number format.
+
+        >>> Format('en_US').compact_currency(1234567, "USD", format_type='short', fraction_digits=2)
+        '$1.23M'
+        """
+        return format_compact_currency(
+            number,
+            currency,
+            format_type=format_type,
+            fraction_digits=fraction_digits,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+    def percent(self, number: float | Decimal | str, format: str | None = None) -> str:
+        """Return a number formatted as percentage for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.percent(0.34)
+        '34%'
+        """
+        return format_percent(
+            number,
+            format,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+    def scientific(self, number: float | Decimal | str) -> str:
+        """Return a number formatted using scientific notation for the locale."""
+        return format_scientific(
+            number,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+
+class LazyProxy:
+    """Class for proxy objects that delegate to a specified function to evaluate
+    the actual object.
+
+    >>> def greeting(name='world'):
+    ...     return 'Hello, %s!' % name
+    >>> lazy_greeting = LazyProxy(greeting, name='Joe')
+    >>> print(lazy_greeting)
+    Hello, Joe!
+    >>> '  ' + lazy_greeting
+    '  Hello, Joe!'
+    >>> '(%s)' % lazy_greeting
+    '(Hello, Joe!)'
+
+    This can be used, for example, to implement lazy translation functions that
+    delay the actual translation until the string is actually used. The
+    rationale for such behavior is that the locale of the user may not always
+    be available. In web applications, you only know the locale when processing
+    a request.
+
+    The proxy implementation attempts to be as complete as possible, so that
+    the lazy objects should mostly work as expected, for example for sorting:
+
+    >>> greetings = [
+    ...     LazyProxy(greeting, 'world'),
+    ...     LazyProxy(greeting, 'Joe'),
+    ...     LazyProxy(greeting, 'universe'),
+    ... ]
+    >>> greetings.sort()
+    >>> for greeting in greetings:
+    ...     print(greeting)
+    Hello, Joe!
+    Hello, universe!
+    Hello, world!
+    """
+
+    __slots__ = [
+        '_func',
+        '_args',
+        '_kwargs',
+        '_value',
+        '_is_cache_enabled',
+        '_attribute_error',
+    ]
+
+    if TYPE_CHECKING:
+        _func: Callable[..., Any]
+        _args: tuple[Any, ...]
+        _kwargs: dict[str, Any]
+        _is_cache_enabled: bool
+        _value: Any
+        _attribute_error: AttributeError | None
+
+    def __init__(
+        self,
+        func: Callable[..., Any],
+        *args: Any,
+        enable_cache: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        # Avoid triggering our own __setattr__ implementation
+        object.__setattr__(self, '_func', func)
+        object.__setattr__(self, '_args', args)
+        object.__setattr__(self, '_kwargs', kwargs)
+        object.__setattr__(self, '_is_cache_enabled', enable_cache)
+        object.__setattr__(self, '_value', None)
+        object.__setattr__(self, '_attribute_error', None)
+
+    @property
+    def value(self) -> Any:
+        if self._value is None:
+            try:
+                value = self._func(*self._args, **self._kwargs)
+            except AttributeError as error:
+                object.__setattr__(self, '_attribute_error', error)
+                raise
+
+            if not self._is_cache_enabled:
+                return value
+            object.__setattr__(self, '_value', value)
+        return self._value
+
+    def __contains__(self, key: object) -> bool:
+        return key in self.value
+
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+    def __dir__(self) -> list[str]:
+        return dir(self.value)
+
+    def __iter__(self) -> Iterator[Any]:
+        return iter(self.value)
+
+    def __len__(self) -> int:
+        return len(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    def __add__(self, other: object) -> Any:
+        return self.value + other
+
+    def __radd__(self, other: object) -> Any:
+        return other + self.value
+
+    def __mod__(self, other: object) -> Any:
+        return self.value % other
+
+    def __rmod__(self, other: object) -> Any:
+        return other % self.value
+
+    def __mul__(self, other: object) -> Any:
+        return self.value * other
+
+    def __rmul__(self, other: object) -> Any:
+        return other * self.value
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.value(*args, **kwargs)
+
+    def __lt__(self, other: object) -> bool:
+        return self.value < other
+
+    def __le__(self, other: object) -> bool:
+        return self.value <= other
+
+    def __eq__(self, other: object) -> bool:
+        return self.value == other
+
+    def __ne__(self, other: object) -> bool:
+        return self.value != other
+
+    def __gt__(self, other: object) -> bool:
+        return self.value > other
+
+    def __ge__(self, other: object) -> bool:
+        return self.value >= other
+
+    def __delattr__(self, name: str) -> None:
+        delattr(self.value, name)
+
+    def __getattr__(self, name: str) -> Any:
+        if self._attribute_error is not None:
+            raise self._attribute_error
+        return getattr(self.value, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        setattr(self.value, name, value)
+
+    def __delitem__(self, key: Any) -> None:
+        del self.value[key]
+
+    def __getitem__(self, key: Any) -> Any:
+        return self.value[key]
+
+    def __setitem__(self, key: Any, value: Any) -> None:
+        self.value[key] = value
+
+    def __copy__(self) -> LazyProxy:
+        return LazyProxy(
+            self._func,
+            enable_cache=self._is_cache_enabled,
+            *self._args,  # noqa: B026
+            **self._kwargs,
+        )
+
+    def __deepcopy__(self, memo: Any) -> LazyProxy:
+        from copy import deepcopy
+
+        return LazyProxy(
+            deepcopy(self._func, memo),
+            enable_cache=deepcopy(self._is_cache_enabled, memo),
+            *deepcopy(self._args, memo),  # noqa: B026
+            **deepcopy(self._kwargs, memo),
+        )
+
+
+class NullTranslations(gettext.NullTranslations):
+    if TYPE_CHECKING:
+        _info: dict[str, str]
+        _fallback: NullTranslations | None
+
+    DEFAULT_DOMAIN = None
+
+    def __init__(self, fp: gettext._TranslationsReader | None = None) -> None:
+        """Initialize a simple translations class which is not backed by a
+        real catalog. Behaves similar to gettext.NullTranslations but also
+        offers Babel's on *gettext methods (e.g. 'dgettext()').
+
+        :param fp: a file-like object (ignored in this class)
+        """
+        # These attributes are set by gettext.NullTranslations when a catalog
+        # is parsed (fp != None). Ensure that they are always present because
+        # some *gettext methods (including '.gettext()') rely on the attributes.
+        self._catalog: dict[tuple[str, Any] | str, str] = {}
+        self.plural: Callable[[float | Decimal], int] = lambda n: int(n != 1)
+        super().__init__(fp=fp)
+        self.files = list(filter(None, [getattr(fp, 'name', None)]))
+        self.domain = self.DEFAULT_DOMAIN
+        self._domains: dict[str, NullTranslations] = {}
+
+    def dgettext(self, domain: str, message: str) -> str:
+        """Like ``gettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).gettext(message)
+
+    def ldgettext(self, domain: str, message: str) -> str:
+        """Like ``lgettext()``, but look the message up in the specified
+        domain.
+        """
+        import warnings
+
+        warnings.warn(
+            'ldgettext() is deprecated, use dgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._domains.get(domain, self).lgettext(message)
+
+    def udgettext(self, domain: str, message: str) -> str:
+        """Like ``ugettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ugettext(message)
+
+    # backward compatibility with 0.9
+    dugettext = udgettext
+
+    def dngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``ngettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ngettext(singular, plural, num)
+
+    def ldngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``lngettext()``, but look the message up in the specified
+        domain.
+        """
+        import warnings
+
+        warnings.warn(
+            'ldngettext() is deprecated, use dngettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._domains.get(domain, self).lngettext(singular, plural, num)
+
+    def udngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``ungettext()`` but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ungettext(singular, plural, num)
+
+    # backward compatibility with 0.9
+    dungettext = udngettext
+
+    # Most of the downwards code, until it gets included in stdlib, from:
+    #    https://bugs.python.org/file10036/gettext-pgettext.patch
+    #
+    # The encoding of a msgctxt and a msgid in a .mo file is
+    # msgctxt + "\x04" + msgid (gettext version >= 0.15)
+    CONTEXT_ENCODING = '%s\x04%s'
+
+    def pgettext(self, context: str, message: str) -> str | object:
+        """Look up the `context` and `message` id in the catalog and return the
+        corresponding message string, as an 8-bit string encoded with the
+        catalog's charset encoding, if known.  If there is no entry in the
+        catalog for the `message` id and `context` , and a fallback has been
+        set, the look up is forwarded to the fallback's ``pgettext()``
+        method. Otherwise, the `message` id is returned.
+        """
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, message)
+        missing = object()
+        tmsg = self._catalog.get(ctxt_msg_id, missing)
+        if tmsg is missing:
+            tmsg = self._catalog.get((ctxt_msg_id, self.plural(1)), missing)
+        if tmsg is not missing:
+            return tmsg
+        if self._fallback:
+            return self._fallback.pgettext(context, message)
+        return message
+
+    def lpgettext(self, context: str, message: str) -> str | bytes | object:
+        """Equivalent to ``pgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        import warnings
+
+        warnings.warn(
+            'lpgettext() is deprecated, use pgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        tmsg = self.pgettext(context, message)
+        encoding = getattr(self, "_output_charset", None) or locale.getpreferredencoding()
+        return tmsg.encode(encoding) if isinstance(tmsg, str) else tmsg
+
+    def npgettext(self, context: str, singular: str, plural: str, num: int) -> str:
+        """Do a plural-forms lookup of a message id.  `singular` is used as the
+        message id for purposes of lookup in the catalog, while `num` is used to
+        determine which plural form to use.  The returned message string is an
+        8-bit string encoded with the catalog's charset encoding, if known.
+
+        If the message id for `context` is not found in the catalog, and a
+        fallback is specified, the request is forwarded to the fallback's
+        ``npgettext()`` method.  Otherwise, when ``num`` is 1 ``singular`` is
+        returned, and ``plural`` is returned in all other cases.
+        """
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_msg_id, self.plural(num))]
+            return tmsg
+        except KeyError:
+            if self._fallback:
+                return self._fallback.npgettext(context, singular, plural, num)
+            if num == 1:
+                return singular
+            else:
+                return plural
+
+    def lnpgettext(self, context: str, singular: str, plural: str, num: int) -> str | bytes:
+        """Equivalent to ``npgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        import warnings
+
+        warnings.warn(
+            'lnpgettext() is deprecated, use npgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_msg_id, self.plural(num))]
+            encoding = getattr(self, "_output_charset", None) or locale.getpreferredencoding()
+            return tmsg.encode(encoding)
+        except KeyError:
+            if self._fallback:
+                return self._fallback.lnpgettext(context, singular, plural, num)
+            if num == 1:
+                return singular
+            else:
+                return plural
+
+    def upgettext(self, context: str, message: str) -> str:
+        """Look up the `context` and `message` id in the catalog and return the
+        corresponding message string, as a Unicode string.  If there is no entry
+        in the catalog for the `message` id and `context`, and a fallback has
+        been set, the look up is forwarded to the fallback's ``upgettext()``
+        method.  Otherwise, the `message` id is returned.
+        """
+        ctxt_message_id = self.CONTEXT_ENCODING % (context, message)
+        missing = object()
+        tmsg = self._catalog.get(ctxt_message_id, missing)
+        if tmsg is missing:
+            if self._fallback:
+                return self._fallback.upgettext(context, message)
+            return str(message)
+        assert isinstance(tmsg, str)
+        return tmsg
+
+    def unpgettext(self, context: str, singular: str, plural: str, num: int) -> str:
+        """Do a plural-forms lookup of a message id.  `singular` is used as the
+        message id for purposes of lookup in the catalog, while `num` is used to
+        determine which plural form to use.  The returned message string is a
+        Unicode string.
+
+        If the message id for `context` is not found in the catalog, and a
+        fallback is specified, the request is forwarded to the fallback's
+        ``unpgettext()`` method.  Otherwise, when `num` is 1 `singular` is
+        returned, and `plural` is returned in all other cases.
+        """
+        ctxt_message_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_message_id, self.plural(num))]
+        except KeyError:
+            if self._fallback:
+                return self._fallback.unpgettext(context, singular, plural, num)
+            tmsg = str(singular) if num == 1 else str(plural)
+        return tmsg
+
+    def dpgettext(self, domain: str, context: str, message: str) -> str | object:
+        """Like `pgettext()`, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).pgettext(context, message)
+
+    def udpgettext(self, domain: str, context: str, message: str) -> str:
+        """Like `upgettext()`, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).upgettext(context, message)
+
+    # backward compatibility with 0.9
+    dupgettext = udpgettext
+
+    def ldpgettext(self, domain: str, context: str, message: str) -> str | bytes | object:
+        """Equivalent to ``dpgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        return self._domains.get(domain, self).lpgettext(context, message)
+
+    def dnpgettext(self, domain: str, context: str, singular: str, plural: str, num: int) -> str:  # fmt: skip
+        """Like ``npgettext``, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).npgettext(context, singular, plural, num)
+
+    def udnpgettext(self, domain: str, context: str, singular: str, plural: str, num: int) -> str:  # fmt: skip
+        """Like ``unpgettext``, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).unpgettext(context, singular, plural, num)
+
+    # backward compatibility with 0.9
+    dunpgettext = udnpgettext
+
+    def ldnpgettext(
+        self,
+        domain: str,
+        context: str,
+        singular: str,
+        plural: str,
+        num: int,
+    ) -> str | bytes:
+        """Equivalent to ``dnpgettext()``, but the translation is returned in
+        the preferred system encoding, if no other encoding was explicitly set
+        with ``bind_textdomain_codeset()``.
+        """
+        return self._domains.get(domain, self).lnpgettext(context, singular, plural, num)
+
+    ugettext = gettext.NullTranslations.gettext
+    ungettext = gettext.NullTranslations.ngettext
+
+
+class Translations(NullTranslations, gettext.GNUTranslations):
+    """An extended translation catalog class."""
+
+    DEFAULT_DOMAIN = 'messages'
+
+    def __init__(
+        self,
+        fp: gettext._TranslationsReader | None = None,
+        domain: str | None = None,
+    ):
+        """Initialize the translations catalog.
+
+        :param fp: the file-like object the translation should be read from
+        :param domain: the message domain (default: 'messages')
+        """
+        super().__init__(fp=fp)
+        self.domain = domain or self.DEFAULT_DOMAIN
+
+    ugettext = gettext.GNUTranslations.gettext
+    ungettext = gettext.GNUTranslations.ngettext
+
+    @classmethod
+    def load(
+        cls,
+        dirname: str | os.PathLike[str] | None = None,
+        locales: Iterable[str | Locale] | Locale | str | None = None,
+        domain: str | None = None,
+    ) -> NullTranslations:
+        """Load translations from the given directory.
+
+        :param dirname: the directory containing the ``MO`` files
+        :param locales: the list of locales in order of preference (items in
+                        this list can be either `Locale` objects or locale
+                        strings)
+        :param domain: the message domain (default: 'messages')
+        """
+        if not domain:
+            domain = cls.DEFAULT_DOMAIN
+        filename = gettext.find(domain, dirname, _locales_to_names(locales))
+        if not filename:
+            return NullTranslations()
+        with open(filename, 'rb') as fp:
+            return cls(fp=fp, domain=domain)
+
+    def __repr__(self) -> str:
+        version = self._info.get('project-id-version')
+        return f'<{type(self).__name__}: "{version}">'
+
+    def add(self, translations: Translations, merge: bool = True):
+        """Add the given translations to the catalog.
+
+        If the domain of the translations is different than that of the
+        current catalog, they are added as a catalog that is only accessible
+        by the various ``d*gettext`` functions.
+
+        :param translations: the `Translations` instance with the messages to
+                             add
+        :param merge: whether translations for message domains that have
+                      already been added should be merged with the existing
+                      translations
+        """
+        domain = getattr(translations, 'domain', self.DEFAULT_DOMAIN)
+        if merge and domain == self.domain:
+            return self.merge(translations)
+
+        existing = self._domains.get(domain)
+        if merge and isinstance(existing, Translations):
+            existing.merge(translations)
+        else:
+            translations.add_fallback(self)
+            self._domains[domain] = translations
+
+        return self
+
+    def merge(self, translations: Translations):
+        """Merge the given translations into the catalog.
+
+        Message translations in the specified catalog override any messages
+        with the same identifier in the existing catalog.
+
+        :param translations: the `Translations` instance with the messages to
+                             merge
+        """
+        if isinstance(translations, gettext.GNUTranslations):
+            self._catalog.update(translations._catalog)
+            if isinstance(translations, Translations):
+                self.files.extend(translations.files)
+
+        return self
+
+
+def _locales_to_names(
+    locales: Iterable[str | Locale] | Locale | str | None,
+) -> list[str] | None:
+    """Normalize a `locales` argument to a list of locale names.
+
+    :param locales: the list of locales in order of preference (items in
+                    this list can be either `Locale` objects or locale
+                    strings)
+    """
+    if locales is None:
+        return None
+    if isinstance(locales, Locale):
+        return [str(locales)]
+    if isinstance(locales, str):
+        return [locales]
+    return [str(locale) for locale in locales]

micromamba_root/Lib/site-packages/babel/units.py

@@ -0,0 +1,362 @@
+from __future__ import annotations
+
+import decimal
+from typing import Literal
+
+from babel.core import Locale
+from babel.numbers import LC_NUMERIC, format_decimal
+
+
+class UnknownUnitError(ValueError):
+    def __init__(self, unit: str, locale: Locale) -> None:
+        ValueError.__init__(self, f"{unit} is not a known unit in {locale}")
+
+
+def get_unit_name(
+    measurement_unit: str,
+    length: Literal['short', 'long', 'narrow'] = 'long',
+    locale: Locale | str | None = None,
+) -> str | None:
+    """
+    Get the display name for a measurement unit in the given locale.
+
+    >>> get_unit_name("radian", locale="en")
+    'radians'
+
+    Unknown units will raise exceptions:
+
+    >>> get_unit_name("battery", locale="fi")
+    Traceback (most recent call last):
+        ...
+    UnknownUnitError: battery/long is not a known unit/length in fi
+
+    :param measurement_unit: the code of a measurement unit.
+                             Known units can be found in the CLDR Unit Validity XML file:
+                             https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+
+    :param length: "short", "long" or "narrow"
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :return: The unit display name, or None.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    unit = _find_unit_pattern(measurement_unit, locale=locale)
+    if not unit:
+        raise UnknownUnitError(unit=measurement_unit, locale=locale)
+    return locale.unit_display_names.get(unit, {}).get(length)
+
+
+def _find_unit_pattern(unit_id: str, locale: Locale | str | None = None) -> str | None:
+    """
+    Expand a unit into a qualified form.
+
+    Known units can be found in the CLDR Unit Validity XML file:
+    https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+
+    >>> _find_unit_pattern("radian", locale="en")
+    'angle-radian'
+
+    Unknown values will return None.
+
+    >>> _find_unit_pattern("horse", locale="en")
+
+    :param unit_id: the code of a measurement unit.
+    :return: A key to the `unit_patterns` mapping, or None.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+    unit_patterns: dict[str, str] = locale._data["unit_patterns"]
+    if unit_id in unit_patterns:
+        return unit_id
+    for unit_pattern in sorted(unit_patterns, key=len):
+        if unit_pattern.endswith(unit_id):
+            return unit_pattern
+    return None
+
+
+def format_unit(
+    value: str | float | decimal.Decimal,
+    measurement_unit: str,
+    length: Literal['short', 'long', 'narrow'] = 'long',
+    format: str | None = None,
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Format a value of a given unit.
+
+    Values are formatted according to the locale's usual pluralization rules
+    and number formats.
+
+    >>> format_unit(12, 'length-meter', locale='ro_RO')
+    '12 metri'
+    >>> format_unit(15.5, 'length-mile', locale='fi_FI')
+    '15,5 mailia'
+    >>> format_unit(1200, 'pressure-millimeter-ofhg', locale='nb')
+    '1\\xa0200 millimeter kvikks\\xf8lv'
+    >>> format_unit(270, 'ton', locale='en')
+    '270 tons'
+    >>> format_unit(1234.5, 'kilogram', locale='ar_EG', numbering_system='default')
+    '1٬234٫5 كيلوغرام'
+
+    Number formats may be overridden with the ``format`` parameter.
+
+    >>> import decimal
+    >>> format_unit(decimal.Decimal("-42.774"), 'temperature-celsius', 'short', format='#.0', locale='fr')
+    '-42,8\\u202f\\xb0C'
+
+    The locale's usual pluralization rules are respected.
+
+    >>> format_unit(1, 'length-meter', locale='ro_RO')
+    '1 metru'
+    >>> format_unit(0, 'length-mile', locale='cy')
+    '0 mi'
+    >>> format_unit(1, 'length-mile', locale='cy')
+    '1 filltir'
+    >>> format_unit(3, 'length-mile', locale='cy')
+    '3 milltir'
+
+    >>> format_unit(15, 'length-horse', locale='fi')
+    Traceback (most recent call last):
+        ...
+    UnknownUnitError: length-horse is not a known unit in fi
+
+    .. versionadded:: 2.2.0
+
+    :param value: the value to format. If this is a string, no number formatting will be attempted.
+    :param measurement_unit: the code of a measurement unit.
+                             Known units can be found in the CLDR Unit Validity XML file:
+                             https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+    :param length: "short", "long" or "narrow"
+    :param format: An optional format, as accepted by `format_decimal`.
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+
+    q_unit = _find_unit_pattern(measurement_unit, locale=locale)
+    if not q_unit:
+        raise UnknownUnitError(unit=measurement_unit, locale=locale)
+    unit_patterns = locale._data["unit_patterns"][q_unit].get(length, {})
+
+    if isinstance(value, str):  # Assume the value is a preformatted singular.
+        formatted_value = value
+        plural_form = "one"
+    else:
+        formatted_value = format_decimal(
+            value,
+            format,
+            locale,
+            numbering_system=numbering_system,
+        )
+        plural_form = locale.plural_form(value)
+
+    if plural_form in unit_patterns:
+        return unit_patterns[plural_form].format(formatted_value)
+
+    # Fall back to a somewhat bad representation.
+    # nb: This is marked as no-cover, as the current CLDR seemingly has no way for this to happen.
+    fallback_name = get_unit_name(  # pragma: no cover
+        measurement_unit,
+        length=length,
+        locale=locale,
+    )
+    return f"{formatted_value} {fallback_name or measurement_unit}"  # pragma: no cover
+
+
+def _find_compound_unit(
+    numerator_unit: str,
+    denominator_unit: str,
+    locale: Locale | str | None = None,
+) -> str | None:
+    """
+    Find a predefined compound unit pattern.
+
+    Used internally by format_compound_unit.
+
+    >>> _find_compound_unit("kilometer", "hour", locale="en")
+    'speed-kilometer-per-hour'
+
+    >>> _find_compound_unit("mile", "gallon", locale="en")
+    'consumption-mile-per-gallon'
+
+    If no predefined compound pattern can be found, `None` is returned.
+
+    >>> _find_compound_unit("gallon", "mile", locale="en")
+
+    >>> _find_compound_unit("horse", "purple", locale="en")
+
+    :param numerator_unit: The numerator unit's identifier
+    :param denominator_unit: The denominator unit's identifier
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :return: A key to the `unit_patterns` mapping, or None.
+    :rtype: str|None
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+
+    # Qualify the numerator and denominator units.  This will turn possibly partial
+    # units like "kilometer" or "hour" into actual units like "length-kilometer" and
+    # "duration-hour".
+
+    resolved_numerator_unit = _find_unit_pattern(numerator_unit, locale=locale)
+    resolved_denominator_unit = _find_unit_pattern(denominator_unit, locale=locale)
+
+    # If either was not found, we can't possibly build a suitable compound unit either.
+    if not (resolved_numerator_unit and resolved_denominator_unit):
+        return None
+
+    # Since compound units are named "speed-kilometer-per-hour", we'll have to slice off
+    # the quantities (i.e. "length", "duration") from both qualified units.
+
+    bare_numerator_unit = resolved_numerator_unit.split("-", 1)[-1]
+    bare_denominator_unit = resolved_denominator_unit.split("-", 1)[-1]
+
+    # Now we can try and rebuild a compound unit specifier, then qualify it:
+
+    return _find_unit_pattern(
+        f"{bare_numerator_unit}-per-{bare_denominator_unit}",
+        locale=locale,
+    )
+
+
+def format_compound_unit(
+    numerator_value: str | float | decimal.Decimal,
+    numerator_unit: str | None = None,
+    denominator_value: str | float | decimal.Decimal = 1,
+    denominator_unit: str | None = None,
+    length: Literal["short", "long", "narrow"] = "long",
+    format: str | None = None,
+    locale: Locale | str | None = None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str | None:
+    """
+    Format a compound number value, i.e. "kilometers per hour" or similar.
+
+    Both unit specifiers are optional to allow for formatting of arbitrary values still according
+    to the locale's general "per" formatting specifier.
+
+    >>> format_compound_unit(7, denominator_value=11, length="short", locale="pt")
+    '7/11'
+
+    >>> format_compound_unit(150, "kilometer", denominator_unit="hour", locale="sv")
+    '150 kilometer per timme'
+
+    >>> format_compound_unit(150, "kilowatt", denominator_unit="year", locale="fi")
+    '150 kilowattia / vuosi'
+
+    >>> format_compound_unit(32.5, "ton", 15, denominator_unit="hour", locale="en")
+    '32.5 tons per 15 hours'
+
+    >>> format_compound_unit(1234.5, "ton", 15, denominator_unit="hour", locale="ar_EG", numbering_system="arab")
+    '1٬234٫5 طن لكل 15 ساعة'
+
+    >>> format_compound_unit(160, denominator_unit="square-meter", locale="fr")
+    '160 par m\\xe8tre carr\\xe9'
+
+    >>> format_compound_unit(4, "meter", "ratakisko", length="short", locale="fi")
+    '4 m/ratakisko'
+
+    >>> format_compound_unit(35, "minute", denominator_unit="nautical-mile", locale="sv")
+    '35 minuter per nautisk mil'
+
+    >>> from babel.numbers import format_currency
+    >>> format_compound_unit(format_currency(35, "JPY", locale="de"), denominator_unit="liter", locale="de")
+    '35\\xa0\\xa5 pro Liter'
+
+    See https://www.unicode.org/reports/tr35/tr35-general.html#perUnitPatterns
+
+    :param numerator_value: The numerator value. This may be a string,
+                            in which case it is considered preformatted and the unit is ignored.
+    :param numerator_unit: The numerator unit. See `format_unit`.
+    :param denominator_value: The denominator value. This may be a string,
+                              in which case it is considered preformatted and the unit is ignored.
+    :param denominator_unit: The denominator unit. See `format_unit`.
+    :param length: The formatting length. "short", "long" or "narrow"
+    :param format: An optional format, as accepted by `format_decimal`.
+    :param locale: the `Locale` object or locale identifier. Defaults to the system numeric locale.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :return: A formatted compound value.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale or LC_NUMERIC)
+
+    # Look for a specific compound unit first...
+
+    if numerator_unit and denominator_unit and denominator_value == 1:
+        compound_unit = _find_compound_unit(numerator_unit, denominator_unit, locale=locale)
+        if compound_unit:
+            return format_unit(
+                numerator_value,
+                compound_unit,
+                length=length,
+                format=format,
+                locale=locale,
+                numbering_system=numbering_system,
+            )
+
+    # ... failing that, construct one "by hand".
+
+    if isinstance(numerator_value, str):  # Numerator is preformatted
+        formatted_numerator = numerator_value
+    elif numerator_unit:  # Numerator has unit
+        formatted_numerator = format_unit(
+            numerator_value,
+            numerator_unit,
+            length=length,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+    else:  # Unitless numerator
+        formatted_numerator = format_decimal(
+            numerator_value,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+
+    if isinstance(denominator_value, str):  # Denominator is preformatted
+        formatted_denominator = denominator_value
+    elif denominator_unit:  # Denominator has unit
+        if denominator_value == 1:  # support perUnitPatterns when the denominator is 1
+            denominator_unit = _find_unit_pattern(denominator_unit, locale=locale)
+            per_pattern = (
+                locale._data["unit_patterns"]
+                .get(denominator_unit, {})
+                .get(length, {})
+                .get("per")
+            )
+            if per_pattern:
+                return per_pattern.format(formatted_numerator)
+            # See TR-35's per-unit pattern algorithm, point 3.2.
+            # For denominator 1, we replace the value to be formatted with the empty string;
+            # this will make `format_unit` return " second" instead of "1 second".
+            denominator_value = ""
+
+        formatted_denominator = format_unit(
+            denominator_value,
+            measurement_unit=(denominator_unit or ""),
+            length=length,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        ).strip()
+    else:  # Bare denominator
+        formatted_denominator = format_decimal(
+            denominator_value,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+
+    # TODO: this doesn't support "compound_variations" (or "prefix"), and will fall back to the "x/y" representation
+    per_pattern = (
+        locale._data["compound_unit_patterns"]
+        .get("per", {})
+        .get(length, {})
+        .get("compound", "{0}/{1}")
+    )
+
+    return per_pattern.format(formatted_numerator, formatted_denominator)

micromamba_root/Lib/site-packages/babel/util.py

@@ -0,0 +1,318 @@
+"""
+babel.util
+~~~~~~~~~~
+
+Various utility classes and functions.
+
+:copyright: (c) 2013-2026 by the Babel Team.
+:license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import codecs
+import datetime
+import os
+import re
+import textwrap
+import warnings
+from collections.abc import Generator, Iterable
+from typing import IO, Any, TypeVar
+
+from babel import dates, localtime
+
+missing = object()
+
+_T = TypeVar("_T")
+
+
+def distinct(iterable: Iterable[_T]) -> Generator[_T, None, None]:
+    """Yield all items in an iterable collection that are distinct.
+
+    Unlike when using sets for a similar effect, the original ordering of the
+    items in the collection is preserved by this function.
+
+    >>> print(list(distinct([1, 2, 1, 3, 4, 4])))
+    [1, 2, 3, 4]
+    >>> print(list(distinct('foobar')))
+    ['f', 'o', 'b', 'a', 'r']
+
+    :param iterable: the iterable collection providing the data
+    """
+    seen = set()
+    for item in iter(iterable):
+        if item not in seen:
+            yield item
+            seen.add(item)
+
+
+# Regexp to match python magic encoding line
+PYTHON_MAGIC_COMMENT_re = re.compile(
+    rb'[ \t\f]* \# .* coding[=:][ \t]*([-\w.]+)',
+    flags=re.VERBOSE,
+)
+
+
+def parse_encoding(fp: IO[bytes]) -> str | None:
+    """Deduce the encoding of a source file from magic comment.
+
+    It does this in the same way as the `Python interpreter`__
+
+    .. __: https://docs.python.org/3.4/reference/lexical_analysis.html#encoding-declarations
+
+    The ``fp`` argument should be a seekable file object.
+
+    (From Jeff Dairiki)
+    """
+    pos = fp.tell()
+    fp.seek(0)
+    try:
+        line1 = fp.readline()
+        has_bom = line1.startswith(codecs.BOM_UTF8)
+        if has_bom:
+            line1 = line1[len(codecs.BOM_UTF8) :]
+
+        m = PYTHON_MAGIC_COMMENT_re.match(line1)
+        if not m:
+            try:
+                import ast
+
+                ast.parse(line1.decode('latin-1'))
+            except (ImportError, SyntaxError, UnicodeEncodeError):
+                # Either it's a real syntax error, in which case the source is
+                # not valid python source, or line2 is a continuation of line1,
+                # in which case we don't want to scan line2 for a magic
+                # comment.
+                pass
+            else:
+                line2 = fp.readline()
+                m = PYTHON_MAGIC_COMMENT_re.match(line2)
+
+        if has_bom:
+            if m:
+                magic_comment_encoding = m.group(1).decode('latin-1')
+                if magic_comment_encoding != 'utf-8':
+                    raise SyntaxError(f"encoding problem: {magic_comment_encoding} with BOM")
+            return 'utf-8'
+        elif m:
+            return m.group(1).decode('latin-1')
+        else:
+            return None
+    finally:
+        fp.seek(pos)
+
+
+PYTHON_FUTURE_IMPORT_re = re.compile(r'from\s+__future__\s+import\s+\(*(.+)\)*')
+
+
+def parse_future_flags(fp: IO[bytes], encoding: str = 'latin-1') -> int:
+    """Parse the compiler flags by :mod:`__future__` from the given Python
+    code.
+    """
+    import __future__
+
+    pos = fp.tell()
+    fp.seek(0)
+    flags = 0
+    try:
+        body = fp.read().decode(encoding)
+
+        # Fix up the source to be (hopefully) parsable by regexpen.
+        # This will likely do untoward things if the source code itself is broken.
+
+        # (1) Fix `import (\n...` to be `import (...`.
+        body = re.sub(r'import\s*\([\r\n]+', 'import (', body)
+        # (2) Join line-ending commas with the next line.
+        body = re.sub(r',\s*[\r\n]+', ', ', body)
+        # (3) Remove backslash line continuations.
+        body = re.sub(r'\\\s*[\r\n]+', ' ', body)
+
+        for m in PYTHON_FUTURE_IMPORT_re.finditer(body):
+            names = [x.strip().strip('()') for x in m.group(1).split(',')]
+            for name in names:
+                feature = getattr(__future__, name, None)
+                if feature:
+                    flags |= feature.compiler_flag
+    finally:
+        fp.seek(pos)
+    return flags
+
+
+def pathmatch(pattern: str, filename: str) -> bool:
+    """Extended pathname pattern matching.
+
+    This function is similar to what is provided by the ``fnmatch`` module in
+    the Python standard library, but:
+
+     * can match complete (relative or absolute) path names, and not just file
+       names, and
+     * also supports a convenience pattern ("**") to match files at any
+       directory level.
+
+    Examples:
+
+    >>> pathmatch('**.py', 'bar.py')
+    True
+    >>> pathmatch('**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('**.py', 'templates/index.html')
+    False
+
+    >>> pathmatch('./foo/**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('./foo/**.py', 'bar/baz.py')
+    False
+
+    >>> pathmatch('^foo/**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('^foo/**.py', 'bar/baz.py')
+    False
+
+    >>> pathmatch('**/templates/*.html', 'templates/index.html')
+    True
+    >>> pathmatch('**/templates/*.html', 'templates/foo/bar.html')
+    False
+
+    :param pattern: the glob pattern
+    :param filename: the path name of the file to match against
+    """
+    symbols = {
+        '?': '[^/]',
+        '?/': '[^/]/',
+        '*': '[^/]+',
+        '*/': '[^/]+/',
+        '**/': '(?:.+/)*?',
+        '**': '(?:.+/)*?[^/]+',
+    }
+
+    if pattern.startswith('^'):
+        buf = ['^']
+        pattern = pattern[1:]
+    elif pattern.startswith('./'):
+        buf = ['^']
+        pattern = pattern[2:]
+    else:
+        buf = []
+
+    for idx, part in enumerate(re.split('([?*]+/?)', pattern)):
+        if idx % 2:
+            buf.append(symbols[part])
+        elif part:
+            buf.append(re.escape(part))
+    match = re.match(f"{''.join(buf)}$", filename.replace(os.sep, "/"))
+    return match is not None
+
+
+class TextWrapper(textwrap.TextWrapper):
+    wordsep_re = re.compile(
+        r'(\s+|'  # any whitespace
+        r'(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))',  # em-dash
+    )
+
+    # e.g. '\u2068foo bar.py\u2069:42'
+    _enclosed_filename_re = re.compile(r'(\u2068[^\u2068]+?\u2069(?::-?\d+)?)')
+
+    def _split(self, text):
+        """Splits the text into indivisible chunks while ensuring that file names
+        containing spaces are not broken up.
+        """
+        enclosed_filename_start = '\u2068'
+        if enclosed_filename_start not in text:
+            # There are no file names which contain spaces, fallback to the default implementation
+            return super()._split(text)
+
+        chunks = []
+        for chunk in re.split(self._enclosed_filename_re, text):
+            if chunk.startswith(enclosed_filename_start):
+                chunks.append(chunk)
+            else:
+                chunks.extend(super()._split(chunk))
+        return [c for c in chunks if c]
+
+
+def wraptext(
+    text: str,
+    width: int = 70,
+    initial_indent: str = '',
+    subsequent_indent: str = '',
+) -> list[str]:
+    """Simple wrapper around the ``textwrap.wrap`` function in the standard
+    library. This version does not wrap lines on hyphens in words. It also
+    does not wrap PO file locations containing spaces.
+
+    :param text: the text to wrap
+    :param width: the maximum line width
+    :param initial_indent: string that will be prepended to the first line of
+                           wrapped output
+    :param subsequent_indent: string that will be prepended to all lines save
+                              the first of wrapped output
+    """
+    warnings.warn(
+        "`babel.util.wraptext` is deprecated and will be removed in a future version of Babel. "
+        "If you need this functionality, use the `babel.util.TextWrapper` class directly.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return TextWrapper(
+        width=width,
+        initial_indent=initial_indent,
+        subsequent_indent=subsequent_indent,
+        break_long_words=False,
+    ).wrap(text)
+
+
+# TODO (Babel 3.x): Remove this re-export
+odict = dict
+
+
+class FixedOffsetTimezone(datetime.tzinfo):
+    """
+    Fixed offset in minutes east from UTC.
+
+    DEPRECATED: Use the standard library `datetime.timezone` instead.
+    """
+
+    # TODO (Babel 3.x): Remove this class
+
+    def __init__(self, offset: float, name: str | None = None) -> None:
+        warnings.warn(
+            "`FixedOffsetTimezone` is deprecated and will be removed in a future version of Babel. "
+            "Use the standard library `datetime.timezone` class.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self._offset = datetime.timedelta(minutes=offset)
+        if name is None:
+            name = 'Etc/GMT%+d' % offset
+        self.zone = name
+
+    def __str__(self) -> str:
+        return self.zone
+
+    def __repr__(self) -> str:
+        return f'<FixedOffset "{self.zone}" {self._offset}>'
+
+    def utcoffset(self, dt: datetime.datetime) -> datetime.timedelta:
+        return self._offset
+
+    def tzname(self, dt: datetime.datetime) -> str:
+        return self.zone
+
+    def dst(self, dt: datetime.datetime) -> datetime.timedelta:
+        return ZERO
+
+
+# Export the localtime functionality here because that's
+# where it was in the past.
+# TODO(3.0): remove these aliases
+UTC = dates.UTC
+LOCALTZ = dates.LOCALTZ
+get_localzone = localtime.get_localzone
+STDOFFSET = localtime.STDOFFSET
+DSTOFFSET = localtime.DSTOFFSET
+DSTDIFF = localtime.DSTDIFF
+ZERO = localtime.ZERO
+
+
+def _cmp(a: Any, b: Any):
+    return (a > b) - (a < b)

micromamba_root/Lib/site-packages/backrefs-7.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+conda

micromamba_root/Lib/site-packages/backrefs-7.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: backrefs
+Version: 7.0
+Summary: A wrapper around re and regex that adds additional back references.
+Project-URL: Homepage, https://github.com/facelessuser/backrefs
+Author-email: Isaac Muse <Isaac.Muse@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.md
+Keywords: re,regex
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: extras
+Requires-Dist: regex; extra == 'extras'
+Description-Content-Type: text/markdown
+
+[![Donate via PayPal][donate-image]][donate-link]
+[![Coverage Status][codecov-image]][codecov-link]
+[![PyPI Version][pypi-image]][pypi-link]
+[![PyPI Downloads][pypi-down]][pypi-link]
+[![PyPI - Python Version][python-image]][pypi-link]
+[![License][license-image-mit]][license-link]
+
+# Backrefs
+
+Backrefs is a wrapper around Python's built-in [Re][re] and the 3rd party [Regex][regex] library.  Backrefs adds various
+additional back references (and a couple other features) that are known to some regular expression engines, but not to
+Python's Re and/or Regex.  The supported back references actually vary depending on the regular expression engine being
+used as the engine may already have support for some.
+
+```python
+>>> from backrefs import bre
+>>> pattern = bre.compile(r'(\p{Letter}+)')
+>>> pattern.sub(r'\C\1\E', 'sometext')
+'SOMETEXT'
+```
+
+# Documentation
+
+https://facelessuser.github.io/backrefs/
+
+# License
+
+MIT
+
+[codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/backrefs/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
+[codecov-link]: https://codecov.io/github/facelessuser/backrefs
+[pypi-image]: https://img.shields.io/pypi/v/backrefs.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
+[pypi-down]: https://img.shields.io/pypi/dm/backrefs.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
+[pypi-link]: https://pypi.python.org/pypi/backrefs
+[python-image]: https://img.shields.io/pypi/pyversions/backrefs?logo=python&logoColor=aaaaaa&labelColor=333333
+[license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
+[license-link]: https://github.com/facelessuser/backrefs/blob/main/LICENSE.md
+[donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
+[donate-link]: https://www.paypal.me/facelessuser
+
+[re]: https://docs.python.org/3/library/re.html
+[regex]: https://pypi.python.org/pypi/regex

micromamba_root/Lib/site-packages/backrefs-7.0.dist-info/RECORD

@@ -0,0 +1,78 @@
+backrefs-7.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+backrefs-7.0.dist-info/METADATA,sha256=kL_4w7oA3i4cWJUxh6aZX6koCAJQP-ca1JsFSTDMMoU,2950
+backrefs-7.0.dist-info/RECORD,,
+backrefs-7.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backrefs-7.0.dist-info/WHEEL,sha256=ojDajBq3ct6non4OtZMDMYPko3aJdmUetNgf7PgkDgk,89
+backrefs-7.0.dist-info/direct_url.json,sha256=_DvuoHK3-1cIOvEvBPWDdca8Uvl9Daecth3HBvyBihE,119
+backrefs-7.0.dist-info/licenses/LICENSE.md,sha256=wRJ7Q2O3NbeJinEnOW_35PqkjljSIcXZ3GFlM_gRolw,1084
+backrefs/__init__.py,sha256=8Qt-anmlWzm-8FEjX1c9xYa47PG8-ccQgWQOAiKA4PM,90
+backrefs/__meta__.py,sha256=dZvWX2DNALnYk-E_ZZ29yTZaRuplYRT_rCDJu-0Qr5w,6766
+backrefs/__pycache__/__init__.cpython-310.pyc,,
+backrefs/__pycache__/__meta__.cpython-310.pyc,,
+backrefs/__pycache__/_bre_parse.cpython-310.pyc,,
+backrefs/__pycache__/_bregex_parse.cpython-310.pyc,,
+backrefs/__pycache__/_bregex_typing.cpython-310.pyc,,
+backrefs/__pycache__/bre.cpython-310.pyc,,
+backrefs/__pycache__/bregex.cpython-310.pyc,,
+backrefs/__pycache__/util.cpython-310.pyc,,
+backrefs/_bre_parse.py,sha256=3-gvvGCMGRrPT5CX9uNTem4hLJUBOsCDGv1lsDoBDgs,53121
+backrefs/_bregex_parse.py,sha256=YCyKr9ZEeydT3w430QfdWkV8axPBFi4ICKCz75-UDwQ,47181
+backrefs/_bregex_typing.py,sha256=THgf80whbUAJrpKWayEMJx8ixrU5oXwmVaQAa8n0DsQ,236
+backrefs/bre.py,sha256=naZaNxLmNUcPgcQTBYR-1rVxfyWPk25cevt0JZu3X0s,19843
+backrefs/bregex.py,sha256=CQ077-rAyjIy6hzL7-Z3rjnpb0VphNduSEc8yjRBalo,20947
+backrefs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backrefs/uniprops/__init__.py,sha256=6Ylu7wHmppGsp-rzW-D937st2fo7SR10ZXYUvsR5SQs,22720
+backrefs/uniprops/__pycache__/__init__.cpython-310.pyc,,
+backrefs/uniprops/unidata/__init__.py,sha256=4hmJdh2Z89-XVgY0BU9vwHClJQFXmQyWZvUmLmpqOsU,64
+backrefs/uniprops/unidata/__pycache__/__init__.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/age.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/alias.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/bidiclass.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/bidipairedbrackettype.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/binary.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/block.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/canonicalcombiningclass.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/decompositiontype.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/eastasianwidth.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/generalcategory.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/graphemeclusterbreak.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/hangulsyllabletype.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/indicpositionalcategory.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/indicsyllabiccategory.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/joininggroup.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/joiningtype.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/linebreak.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/numerictype.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/numericvalue.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/quickcheck.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/script.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/scriptextensions.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/sentencebreak.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/verticalorientation.cpython-310.pyc,,
+backrefs/uniprops/unidata/__pycache__/wordbreak.cpython-310.pyc,,
+backrefs/uniprops/unidata/age.py,sha256=IQdRIGXjJZOyERlyaw--2N0D1kuCna9AsKoJjpUT2Kw,67580
+backrefs/uniprops/unidata/alias.py,sha256=Kr5epc3yiquCVZIAh9nsHvvFRKVt06Kjt3qtLgEaUxw,22967
+backrefs/uniprops/unidata/bidiclass.py,sha256=IrzoiTOspQnv4bJ1jXTrwoVOVd3OgeeDNAXgPaZyoAU,42795
+backrefs/uniprops/unidata/bidipairedbrackettype.py,sha256=7irbKlDIIQzn5veY4TB5eiZ3vDLlntJLkJ8QMTXyFoI,3090
+backrefs/uniprops/unidata/binary.py,sha256=TymHcEUW2WjtAYxgslYfLxebkHphqfmip6Z8YPx46DA,388118
+backrefs/uniprops/unidata/block.py,sha256=qvGzVYf9vnyVsugtwwD4AY88bCZM6_aBNC-bLYqHnS4,55282
+backrefs/uniprops/unidata/canonicalcombiningclass.py,sha256=dHscCj-oQ079Up_17Fp-X8ZqObDFHKntiUqOYe6vYzw,36976
+backrefs/uniprops/unidata/decompositiontype.py,sha256=uh2xuHQuXP4UB8kbFEAZF31jJrVQkV8KPSmFlftsRZs,26912
+backrefs/uniprops/unidata/eastasianwidth.py,sha256=gW6tz7Oc6-oNFLCtpZD7bqYw-HDmUVtJp73GeSN45oQ,15108
+backrefs/uniprops/unidata/generalcategory.py,sha256=J-VqKl-tA87Gd3fqt3IMuU1heMPVlJ8EgBUAoLBN0sk,130520
+backrefs/uniprops/unidata/graphemeclusterbreak.py,sha256=nbGc8iE4rWXeztuG8GhqaYWqnaN6fv2iPgK9qHJi9QM,40875
+backrefs/uniprops/unidata/hangulsyllabletype.py,sha256=EgjfnsOz1ARQE_oBfiTFPY7HUw0ctGQYo0XjbiT2WK0,16173
+backrefs/uniprops/unidata/indicpositionalcategory.py,sha256=lKUMImOsbinJKe5luY6eoLY2IugOQapLFpftQsY5tZg,23630
+backrefs/uniprops/unidata/indicsyllabiccategory.py,sha256=GfvRadQ9LNLG4aHTUbqy9z2A8MGy_hiXMHFRrW1xBoc,34031
+backrefs/uniprops/unidata/joininggroup.py,sha256=JjrGIgsE4RdHi-dgveof4WW1XIUOwChAb4pijACf7bE,17426
+backrefs/uniprops/unidata/joiningtype.py,sha256=L7Aq6ck6CVewxA39rrw-Sxa_nDBrrM7IqJ-KZ5IkuDk,23444
+backrefs/uniprops/unidata/linebreak.py,sha256=SuhXXI-Qv1Rxu9oc2n7tcByU0OYb_P4KzahOMj7VPgE,88850
+backrefs/uniprops/unidata/numerictype.py,sha256=iMl6ALFpJXjETx6iLrIZ9_B-CTCYQ0wCz8JpbVsenuw,13259
+backrefs/uniprops/unidata/numericvalue.py,sha256=hE-PwRf3-sawlgDYF5F1wOSuYohOgLBTJg_mwgHeWSQ,66531
+backrefs/uniprops/unidata/quickcheck.py,sha256=m6mMe0kCeR5ZiWCsPkPQYCWomlRLsd3KuEm8MXL7diU,47014
+backrefs/uniprops/unidata/script.py,sha256=1s7iAsALdA6IeRco9hFtf4KDy0yXl7NJR8sfdImyeUw,64788
+backrefs/uniprops/unidata/scriptextensions.py,sha256=ZEj1jiVT6kw-AsYtReeu0DlvGlUSi03IMUyjMv29zeQ,69629
+backrefs/uniprops/unidata/sentencebreak.py,sha256=V_1mPfXllfLJO-9fImlty6a5Z8E8o0qBHiojxyTjEAo,73389
+backrefs/uniprops/unidata/verticalorientation.py,sha256=lltUNd4YEBf68XqluOb1XGvbszO2DBQkhWUsj1y1Da8,6776
+backrefs/uniprops/unidata/wordbreak.py,sha256=LUftxtrRfNsS3NbLRDwrqUmkTbj3KcBKBpWiCSAkQRw,51319
+backrefs/util.py,sha256=2qnLiUsB06IKKIdrjWIxYqwUG7OFqtOhafgx23ZwBn8,4285

micromamba_root/Lib/site-packages/backrefs-7.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py310-none-any

micromamba_root/Lib/site-packages/backrefs-7.0.dist-info/direct_url.json

@@ -0,0 +1 @@
+{"dir_info": {}, "url": "file:///home/conda/feedstock_root/build_artifacts/bld/rattler-build_backrefs_1777493261/work"}

micromamba_root/Lib/site-packages/backrefs/__init__.py

@@ -0,0 +1,2 @@
+"""Backrefs package."""
+from .__meta__ import __version__, __version_info__  # noqa: F401

micromamba_root/Lib/site-packages/backrefs/__meta__.py

@@ -0,0 +1,197 @@
+"""Meta related things."""
+from __future__ import annotations
+from collections import namedtuple
+import re
+
+RE_VER = re.compile(
+    r'''(?x)
+    (?P<major>\d+)(?:\.(?P<minor>\d+))?(?:\.(?P<micro>\d+))?
+    (?:(?P<type>a|b|rc)(?P<pre>\d+))?
+    (?:\.post(?P<post>\d+))?
+    (?:\.dev(?P<dev>\d+))?
+    '''
+)
+
+REL_MAP = {
+    ".dev": "",
+    ".dev-alpha": "a",
+    ".dev-beta": "b",
+    ".dev-candidate": "rc",
+    "alpha": "a",
+    "beta": "b",
+    "candidate": "rc",
+    "final": ""
+}
+
+DEV_STATUS = {
+    ".dev": "2 - Pre-Alpha",
+    ".dev-alpha": "2 - Pre-Alpha",
+    ".dev-beta": "2 - Pre-Alpha",
+    ".dev-candidate": "2 - Pre-Alpha",
+    "alpha": "3 - Alpha",
+    "beta": "4 - Beta",
+    "candidate": "4 - Beta",
+    "final": "5 - Production/Stable"
+}
+
+PRE_REL_MAP = {"a": 'alpha', "b": 'beta', "rc": 'candidate'}
+
+
+class Version(namedtuple("Version", ["major", "minor", "micro", "release", "pre", "post", "dev"])):
+    """
+    Get the version (PEP 440).
+
+    A biased approach to the PEP 440 semantic version.
+
+    Provides a tuple structure which is sorted for comparisons `v1 > v2` etc.
+      (major, minor, micro, release type, pre-release build, post-release build, development release build)
+    Release types are named in is such a way they are comparable with ease.
+    Accessors to check if a development, pre-release, or post-release build. Also provides accessor to get
+    development status for setup files.
+
+    How it works (currently):
+
+    - You must specify a release type as either `final`, `alpha`, `beta`, or `candidate`.
+    - To define a development release, you can use either `.dev`, `.dev-alpha`, `.dev-beta`, or `.dev-candidate`.
+      The dot is used to ensure all development specifiers are sorted before `alpha`.
+      You can specify a `dev` number for development builds, but do not have to as implicit development releases
+      are allowed.
+    - You must specify a `pre` value greater than zero if using a prerelease as this project (not PEP 440) does not
+      allow implicit prereleases.
+    - You can optionally set `post` to a value greater than zero to make the build a post release. While post releases
+      are technically allowed in prereleases, it is strongly discouraged, so we are rejecting them. It should be
+      noted that we do not allow `post0` even though PEP 440 does not restrict this. This project specifically
+      does not allow implicit post releases.
+    - It should be noted that we do not support epochs `1!` or local versions `+some-custom.version-1`.
+
+    Acceptable version releases:
+
+    ```
+    Version(1, 0, 0, "final")                    1.0
+    Version(1, 2, 0, "final")                    1.2
+    Version(1, 2, 3, "final")                    1.2.3
+    Version(1, 2, 0, ".dev-alpha", pre=4)        1.2a4
+    Version(1, 2, 0, ".dev-beta", pre=4)         1.2b4
+    Version(1, 2, 0, ".dev-candidate", pre=4)    1.2rc4
+    Version(1, 2, 0, "final", post=1)            1.2.post1
+    Version(1, 2, 3, ".dev")                     1.2.3.dev0
+    Version(1, 2, 3, ".dev", dev=1)              1.2.3.dev1
+    ```
+
+    """
+
+    def __new__(
+        cls,
+        major: int, minor: int, micro: int, release: str = "final",
+        pre: int = 0, post: int = 0, dev: int = 0
+    ) -> Version:
+        """Validate version info."""
+
+        # Ensure all parts are positive integers.
+        for value in (major, minor, micro, pre, post):
+            if not (isinstance(value, int) and value >= 0):
+                raise ValueError("All version parts except 'release' should be integers.")
+
+        if release not in REL_MAP:
+            raise ValueError(f"'{release}' is not a valid release type.")
+
+        # Ensure valid pre-release (we do not allow implicit pre-releases).
+        if ".dev-candidate" < release < "final":
+            if pre == 0:
+                raise ValueError("Implicit pre-releases not allowed.")
+            elif dev:
+                raise ValueError("Version is not a development release.")
+            elif post:
+                raise ValueError("Post-releases are not allowed with pre-releases.")
+
+        # Ensure valid development or development/pre release
+        elif release < "alpha":
+            if release > ".dev" and pre == 0:
+                raise ValueError("Implicit pre-release not allowed.")
+            elif post:
+                raise ValueError("Post-releases are not allowed with pre-releases.")
+
+        # Ensure a valid normal release
+        else:
+            if pre:
+                raise ValueError("Version is not a pre-release.")
+            elif dev:
+                raise ValueError("Version is not a development release.")
+
+        return super().__new__(cls, major, minor, micro, release, pre, post, dev)
+
+    def _is_pre(self) -> bool:
+        """Is prerelease."""
+
+        return bool(self.pre > 0)
+
+    def _is_dev(self) -> bool:
+        """Is development."""
+
+        return bool(self.release < "alpha")
+
+    def _is_post(self) -> bool:
+        """Is post."""
+
+        return bool(self.post > 0)
+
+    def _get_dev_status(self) -> str:  # pragma: no cover
+        """Get development status string."""
+
+        return DEV_STATUS[self.release]
+
+    def _get_canonical(self) -> str:
+        """Get the canonical output string."""
+
+        # Assemble major, minor, micro version and append `pre`, `post`, or `dev` if needed..
+        if self.micro == 0:
+            ver = f"{self.major}.{self.minor}"
+        else:
+            ver = f"{self.major}.{self.minor}.{self.micro}"
+        if self._is_pre():
+            ver += f'{REL_MAP[self.release]}{self.pre}'
+        if self._is_post():
+            ver += f".post{self.post}"
+        if self._is_dev():
+            ver += f".dev{self.dev}"
+
+        return ver
+
+
+def parse_version(ver: str) -> Version:
+    """Parse version into a comparable Version tuple."""
+
+    m = RE_VER.match(ver)
+
+    if m is None:
+        raise ValueError(f"'{ver}' is not a valid version")
+
+    # Handle major, minor, micro
+    major = int(m.group('major'))
+    minor = int(m.group('minor')) if m.group('minor') else 0
+    micro = int(m.group('micro')) if m.group('micro') else 0
+
+    # Handle pre releases
+    if m.group('type'):
+        release = PRE_REL_MAP[m.group('type')]
+        pre = int(m.group('pre'))
+    else:
+        release = "final"
+        pre = 0
+
+    # Handle development releases
+    dev = m.group('dev') if m.group('dev') else 0
+    if m.group('dev'):
+        dev = int(m.group('dev'))
+        release = '.dev-' + release if pre else '.dev'
+    else:
+        dev = 0
+
+    # Handle post
+    post = int(m.group('post')) if m.group('post') else 0
+
+    return Version(major, minor, micro, release, pre, post, dev)
+
+
+__version_info__ = Version(7, 0, 0, "final")
+__version__ = __version_info__._get_canonical()

micromamba_root/Lib/site-packages/backrefs/_bre_parse.py

@@ -0,0 +1,1547 @@
+"""
+Backrefs Re parser.
+
+Licensed under MIT
+Copyright (c) 2011 - 2020 Isaac Muse <isaacmuse@gmail.com>
+"""
+from __future__ import annotations
+import re as _re
+import sys
+import copyreg as _copyreg
+from . import util as _util
+import unicodedata as _unicodedata
+from . import uniprops as _uniprops
+from typing import Generic, AnyStr, Match, Any, Pattern, cast
+
+if sys.version_info >= (3, 11):
+    import re._parser as _parser  # type: ignore[import]
+else:
+    import sre_parse as _parser
+
+__all__ = ("ReplaceTemplate",)
+
+_ASCII_LETTERS = frozenset(
+    (
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+        'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+        'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
+    )
+)
+_DIGIT = frozenset(('0', '1', '2', '3', '4', '5', '6', '7', '8', '9'))
+_OCTAL = frozenset(('0', '1', '2', '3', '4', '5', '6', '7'))
+_HEX = frozenset(('a', 'b', 'c', 'd', 'e', 'f', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'))
+_LETTERS_UNDERSCORE = _ASCII_LETTERS | frozenset(('_',))
+_WORD = _LETTERS_UNDERSCORE | _DIGIT
+_STANDARD_ESCAPES = frozenset(('a', 'b', 'f', 'n', 'r', 't', 'v'))
+_CURLY_BRACKETS = frozenset(('{', '}'))
+_PROPERTY_STRIP = frozenset((' ', '-', '_'))
+_PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP
+_GLOBAL_FLAGS = frozenset(('a', 'i', 'L', 'm', 's', 'u', 'x'))
+_SCOPED_FLAGS = frozenset(('i', 'm', 's', 'x'))
+_SCOPED_END = frozenset((':', ')'))
+
+_CURLY_BRACKETS_ORD = frozenset((0x7b, 0x7d))
+
+_COMPATIBILITY_PROPERTIES = frozenset(
+    (
+        'alpha', 'lower', 'upper', 'punct', 'digit', 'xdigit', 'alnum',
+        'space', 'blank', 'cntrl', 'graph', 'print', 'word'
+    )
+)
+
+# Case upper or lower
+_UPPER = 1
+_LOWER = 2
+
+# Format Constants
+_BACK_SLASH_TRANSLATION = {
+    "\\a": '\a',
+    "\\b": '\b',
+    "\\f": '\f',
+    "\\r": '\r',
+    "\\t": '\t',
+    "\\n": '\n',
+    "\\v": '\v',
+    "\\\\": '\\'
+}
+
+_FMT_CONV_TYPE = ('a', 'r', 's')
+
+
+class LoopException(Exception):
+    """Loop exception."""
+
+
+class GlobalRetryException(Exception):
+    """Global retry exception."""
+
+
+class _SearchParser(Generic[AnyStr]):
+    """Search Template."""
+
+    _new_refs = ("c", "C", "e", "E", "h", "l", "L", "m", "M", "N", "p", "P", "Q", "R", "X")
+    _re_start_wb = r"\b(?=\w)"
+    _re_end_wb = r"\b(?<=\w)"
+    _line_break = r'(?:\r\n|(?!\r\n)[\n\v\f\r\x85\u2028\u2029])'
+    _bytes_line_break = r'(?>\r\n|[\n\v\f\r\x85])' if _util.PY311 else r'(?:\r\n|(?!\r\n)[\n\v\f\r\x85])'
+    _grapheme_cluster = r'(?:{}{}*(?!{}))'
+
+    verbose: bool
+    unicode: bool
+    global_flag_swap: dict[str, bool]
+    temp_global_flag_swap: dict[str, bool]
+    ascii: bool  # noqa: A003
+    is_bytes: bool
+    search: AnyStr
+
+    def __init__(self, search: AnyStr, re_verbose: bool = False, re_unicode: bool | None = None) -> None:
+        """Initialize."""
+
+        if isinstance(search, bytes):
+            self.is_bytes = True
+        else:
+            self.is_bytes = False
+
+        if self.is_bytes:
+            self._re_line_break = self._bytes_line_break
+        else:
+            self._re_line_break = self._line_break
+        self.search = search
+        self.re_verbose = re_verbose
+        self.re_unicode = re_unicode
+
+    def process_quotes(self, text: str) -> str:
+        """Process quotes."""
+
+        escaped = False
+        in_quotes = False
+        current = []
+        quoted = []  # type: list[str]
+        i = _util.StringIter(text)
+
+        for t in i:
+            if not escaped and t == "\\":
+                escaped = True
+            elif escaped:
+                escaped = False
+                if t == "E":
+                    if in_quotes:
+                        current.append(_re.escape("".join(quoted)))
+                        quoted = []
+                        in_quotes = False
+                elif t == "Q" and not in_quotes:
+                    in_quotes = True
+                elif in_quotes:
+                    quoted.extend(["\\", t])
+                else:
+                    current.extend(["\\", t])
+            elif in_quotes:
+                quoted.extend(t)
+            else:
+                current.append(t)
+
+        if in_quotes and escaped:
+            quoted.append("\\")
+        elif escaped:
+            current.append("\\")
+
+        if quoted:
+            current.append(_re.escape("".join(quoted)))
+
+        return "".join(current)
+
+    def verbose_comment(self, t: str, i: _util.StringIter) -> list[str]:
+        """Handle verbose comments."""
+
+        current = []
+        escaped = False
+
+        try:
+            while t != "\n":
+                if not escaped and t == "\\":
+                    escaped = True
+                    current.append(t)
+                elif escaped:
+                    escaped = False
+                    if t in self._new_refs:
+                        current.append("\\")
+                    current.append(t)
+                else:
+                    current.append(t)
+                t = next(i)
+        except StopIteration:
+            pass
+
+        if t == "\n":
+            current.append(t)
+        return current
+
+    def flags(self, text: str, scoped: bool = False) -> None:
+        """Analyze flags."""
+
+        flags = text.split('-')
+        enable = flags[0]
+        disable = flags[1] if len(flags) > 1 else ''
+
+        global_retry = False
+        if ('a' in enable or 'L' in enable) and self.unicode:
+            self.unicode = False
+            if not scoped:
+                self.temp_global_flag_swap["unicode"] = True
+                global_retry = True
+        elif 'u' in enable and not self.unicode and not self.is_bytes:
+            self.unicode = True
+            if not scoped:
+                self.temp_global_flag_swap["unicode"] = True
+                global_retry = True
+        if 'x' in disable and self.verbose:
+            self.verbose = False
+        elif 'x' in enable and not self.verbose:
+            self.verbose = True
+            if not scoped:
+                self.temp_global_flag_swap["verbose"] = True
+                global_retry = True
+        if global_retry:
+            raise GlobalRetryException('Global Retry')
+
+    def get_unicode_property(self, i: _util.StringIter, brackets: bool = False) -> tuple[str, str]:
+        """Get Unicode property."""
+
+        index = i.index
+        prop = []
+        value = []
+        try:
+            c = next(i)
+            if c.upper() in _ASCII_LETTERS:
+                prop.append(c)
+            elif (not brackets and c != '{') or (brackets and c != ':'):
+                raise SyntaxError(f"Unicode property missing '{{' at {i.index - 1}!")
+            else:
+                c = next(i)
+                if c == '^':
+                    prop.append(c)
+                    c = next(i)
+
+                while c not in (':', '=', '}'):
+                    if c not in _PROPERTY:
+                        raise SyntaxError(f'Invalid Unicode property character at {i.index - 1}!')
+                    if c not in _PROPERTY_STRIP:
+                        prop.append(c)
+                    c = next(i)
+
+                if c in (':', '='):
+                    skip = False
+                    if brackets:
+                        is_colon = c == ':'
+                        c = next(i)
+                        if is_colon and c == ']':
+                            # That's the end of the property
+                            skip = True
+                        end = ':'
+                    else:
+                        c = next(i)
+                        end = '}'
+
+                    # Get the property value
+                    if not skip:
+                        while c != end:
+                            if c not in _PROPERTY:
+                                raise SyntaxError(f'Invalid Unicode property character at {i.index - 1}!')
+                            if c not in _PROPERTY_STRIP:
+                                value.append(c)
+                            c = next(i)
+                        if brackets and c == ':':
+                            c = next(i)
+                            if c != ']':
+                                raise SyntaxError(f'Invalid Unicode property character at {i.index - 1}!')
+                        if not value:
+                            raise SyntaxError('Invalid Unicode property!')
+
+        except StopIteration as e:
+            if brackets:
+                raise SyntaxError(f"Missing or unmatched ':]' at {index}!") from e
+            else:
+                raise SyntaxError(f"Missing or unmatched '{{' at {index}!") from e
+
+        p = ''.join(prop).lower()
+        v = ''.join(value).lower()
+
+        # Ensure when using POSIX form, that any property considered a compatibility property uses the POSIX form.
+        # POSIX form is not guaranteed to be different from standard form and sometimes is just an alias for standard.
+        if brackets and p in _COMPATIBILITY_PROPERTIES:
+            p = 'posix' + p
+
+        return p, v
+
+    def get_named_unicode(self, i: _util.StringIter) -> str:
+        """Get Unicode name."""
+
+        index = i.index
+        value = []
+        try:
+            if next(i) != '{':
+                raise ValueError(f"Named Unicode missing '{{' {i.index - 1}!")
+            c = next(i)
+            while c != '}':
+                value.append(c)
+                c = next(i)
+        except Exception as e:
+            raise SyntaxError(f"Unmatched '{{' at {index}!") from e
+
+        return ''.join(value)
+
+    def reference(self, t: str, i: _util.StringIter, in_group: bool = False) -> list[str]:
+        """Handle references."""
+
+        current = []
+
+        if not in_group and t == "m":
+            current.append(self._re_start_wb)
+        elif not in_group and t == "M":
+            current.append(self._re_end_wb)
+        elif not in_group and t == "R":
+            current.append(self._re_line_break)
+        elif not in_group and t == "X":
+            no_mark = self.unicode_props("^m", None, in_group=False)[0]
+            mark = self.unicode_props("m", None, in_group=False)[0]
+            current.extend(self._grapheme_cluster.format(no_mark, mark, mark))
+        elif t == 'p':
+            prop = self.get_unicode_property(i)
+            current.extend(self.unicode_props(prop[0], prop[1], in_group=in_group))
+            if in_group:
+                self.found_property = True
+        elif t == 'P':
+            prop = self.get_unicode_property(i)
+            current.extend(self.unicode_props(prop[0], prop[1], in_group=in_group, negate=True))
+            if in_group:
+                self.found_property = True
+        elif t == "N":
+            text = self.get_named_unicode(i)
+            current.extend(self.unicode_name(text, in_group))
+            if in_group:
+                self.found_named_unicode = True
+        else:
+            current.extend(["\\", t])
+        return current
+
+    def get_comments(self, i: _util.StringIter) -> str | None:
+        """Get comments."""
+
+        index = i.index
+        value = ['(']
+        escaped = False
+        try:
+            c = next(i)
+            if c != '?':
+                i.rewind(1)
+                return None
+            value.append(c)
+            c = next(i)
+            if c != '#':
+                i.rewind(2)
+                return None
+            value.append(c)
+            c = next(i)
+            while c != ')' or escaped is True:
+                if escaped:
+                    escaped = False
+                elif c == '\\':
+                    escaped = True
+                value.append(c)
+                c = next(i)
+            value.append(c)
+        except StopIteration as e:
+            raise SyntaxError(f"Unmatched '(' at {index - 1}!") from e
+
+        return ''.join(value)
+
+    def get_flags(self, i: _util.StringIter) -> tuple[str | None, bool]:
+        """
+        Get flags.
+
+        In Re, flags are quite predictable when global or scoped.
+        Global can never be disabled with minus, and never have a `:` after them.
+        The global flag set is also very specific, but can be used as enablers in scoped.
+
+        The returned scoped status will indicate whether flags are generally considered
+        scoped flags or global flags.
+        """
+
+        index = i.index
+        value = ['(']
+        toggle = False
+        smells_scoped = False
+        try:
+            c = next(i)
+            if c != '?':
+                i.rewind(1)
+                return None, False
+            value.append(c)
+            c = next(i)
+            while c not in _SCOPED_END:
+                if toggle:
+                    if c not in _SCOPED_FLAGS:
+                        raise ValueError('Bad scope')
+                elif c == '-':
+                    smells_scoped = True
+                    toggle = True
+                elif c not in _GLOBAL_FLAGS:
+                    raise ValueError("Bad flag")
+                value.append(c)
+                c = next(i)
+            if smells_scoped and c != ':':
+                raise ValueError("Bad flag")
+            elif c == ':':
+                smells_scoped = True
+            value.append(c)
+        except Exception:
+            i.rewind(i.index - index)
+            value = []
+
+        return ''.join(value) if value else None, smells_scoped
+
+    def subgroup(self, t: str, i: _util.StringIter) -> list[str]:
+        """Handle parenthesis."""
+
+        current = []  # type: list[str]
+
+        # (?#comment)
+        comments = self.get_comments(i)
+        if comments:
+            return [comments]
+
+        verbose = self.verbose
+        unicode_flag = self.unicode
+
+        # (?flags:pattern) or (?flags)
+        flags, scoped = self.get_flags(i)
+        if flags:  # pragma: no cover
+            t = flags
+            self.flags(flags[2:-1], scoped=scoped)
+            if not scoped:
+                return [flags]
+
+        current = []
+        try:
+            while t != ')':
+                if not current:
+                    current.append(t)
+                else:
+                    current.extend(self.normal(t, i))
+
+                t = next(i)
+        except StopIteration:
+            pass
+
+        # Restore flags after group
+        self.verbose = verbose
+        self.unicode = unicode_flag
+
+        if t == ")":
+            current.append(t)
+        return current
+
+    def char_groups(self, t: str, i: _util.StringIter) -> list[str]:
+        """Handle character groups."""
+
+        current = []
+        pos = i.index - 1
+        found = False
+        escaped = False
+        first = 0
+        found_property = False
+        self.found_property = False
+        self.found_named_unicode = False
+
+        try:
+            while True:
+                # Prevent POSIX/Unicode class from being part of a range.
+                if self.found_property and t == '-':
+                    current.append(_re.escape(t))
+                    pos += 1
+                    t = next(i)
+                    self.found_property = False
+                    continue
+                else:
+                    self.found_property = False
+
+                if not escaped and t == "\\":
+                    escaped = True
+                elif escaped:
+                    escaped = False
+                    idx = len(current) - 1
+                    current.extend(self.reference(t, i, True))
+                    if self.found_property:
+                        # Prevent Unicode class from being part of a range.
+                        if idx >= 0 and current[idx] == '-':
+                            current[idx] = _re.escape('-')
+                        found_property = True
+                elif t == "[" and not found:
+                    found = True
+                    first = pos
+                    current.append(t)
+                elif t == "[":
+                    index = i.index
+                    try:
+                        prop = self.get_unicode_property(i, True)  # type: tuple[str, str] | None
+                    except Exception:
+                        prop = None
+                        i.rewind(i.index - index)
+                    if prop is not None:
+                        value = self.unicode_props(prop[0], prop[1], in_group=True)
+                        if current[-1] == '-':
+                            current[-1] = _re.escape('-')
+                        current.extend(value)
+                        found_property = True
+                        pos = i.index - 2
+                    else:
+                        current.append(t)
+                elif t == "^" and found and (pos == first + 1):
+                    first = pos
+                    current.append(t)
+                elif t == "]" and found and (pos != first + 1):
+                    found = False
+                    current.append(t)
+                    break
+                else:
+                    current.append(t)
+                pos += 1
+                t = next(i)
+        except StopIteration:
+            pass
+
+        if escaped:
+            current.append(t)
+
+        # Handle properties that return an empty string.
+        # This will occur when a property's values exceed
+        # either the Unicode char limit on a narrow system,
+        # or the ASCII limit in a byte string pattern.
+        if found_property or self.found_named_unicode:
+            temp = "".join(current)
+            if temp == '[]':
+                # We specified some properties, but they are all
+                # out of reach.  Therefore we can match nothing.
+                current = [f'[^{_uniprops.ASCII_RANGE if self.is_bytes else _uniprops.UNICODE_RANGE}]']
+            elif temp == '[^]':
+                current = [f'[{_uniprops.ASCII_RANGE if self.is_bytes else _uniprops.UNICODE_RANGE}]']
+            else:
+                current = [temp]
+
+        return current
+
+    def normal(self, t: str, i: _util.StringIter) -> list[str]:
+        """Handle normal chars."""
+
+        current = []
+
+        if t == "\\":
+            try:
+                t = next(i)
+                current.extend(self.reference(t, i))
+            except StopIteration:
+                current.append(t)
+        elif t == "(":
+            current.extend(self.subgroup(t, i))
+        elif self.verbose and t == "#":
+            current.extend(self.verbose_comment(t, i))
+        elif t == "[":
+            current.extend(self.char_groups(t, i))
+        else:
+            current.append(t)
+        return current
+
+    def unicode_name(self, name: str, in_group: bool = False) -> list[str]:
+        """Insert Unicode value by its name."""
+
+        value = ord(_unicodedata.lookup(name))
+        if self.is_bytes and value > 0xFF:
+            if not in_group:
+                return [f'[^{_uniprops.ASCII_RANGE if self.is_bytes else _uniprops.UNICODE_RANGE}]']
+            else:
+                return ['']
+        return [f'\\{value:03o}' if value <= 0xFF else chr(value)]
+
+    def unicode_props(
+        self,
+        props: str,
+        prop_value: str | None,
+        in_group: bool = False,
+        negate: bool = False
+    ) -> list[str]:
+        """
+        Insert Unicode properties.
+
+        Unicode properties are very forgiving.
+        Case doesn't matter and `[ -_]` will be stripped out.
+        """
+
+        if props.startswith("^"):
+            if negate:
+                props = props[1:]
+        elif negate:
+            props = '^' + props
+        if not prop_value and prop_value is not None:
+            prop_value = None
+
+        if self.is_bytes:
+            mode = _uniprops.MODE_ASCII
+        elif not self.unicode:
+            mode = _uniprops.MODE_NORMAL
+        else:
+            mode = _uniprops.MODE_UNICODE
+
+        v = _uniprops.get_unicode_property(props, prop_value, mode)
+        if not in_group:
+            if not v:
+                v = f'^{_uniprops.ASCII_RANGE if self.is_bytes else _uniprops.UNICODE_RANGE}'
+            v = f"[{v}]"
+        properties = [v]
+
+        return properties
+
+    def main_group(self, i: _util.StringIter) -> list[str]:
+        """The main group: group 0."""
+
+        current = []
+        try:
+            while True:
+                t = next(i)
+                current.extend(self.normal(t, i))
+        except StopIteration:
+            pass
+        return current
+
+    def _parse(self, search: str) -> str:
+        """Begin parsing."""
+
+        self.verbose = bool(self.re_verbose)
+        self.unicode = bool(self.re_unicode)
+        self.global_flag_swap = {
+            "unicode": False,
+            "verbose": False
+        }
+        self.temp_global_flag_swap = {
+            "unicode": False,
+            "verbose": False
+        }
+        self.ascii = self.re_unicode is not None and not self.re_unicode
+        if not self.unicode and not self.ascii:
+            self.unicode = True
+
+        new_pattern = []
+        i = _util.StringIter(self.process_quotes(search))
+
+        retry = True
+        while retry:
+            retry = False
+            try:
+                new_pattern = self.main_group(i)
+            except GlobalRetryException as e:
+                # Prevent a loop of retry over and over for a pattern like ((?u)(?a))
+                # or (?-x:(?x))
+                if self.temp_global_flag_swap['unicode']:
+                    if self.global_flag_swap['unicode']:
+                        raise LoopException('Global unicode flag recursion.') from e
+                    else:
+                        self.global_flag_swap["unicode"] = True
+                if self.temp_global_flag_swap['verbose']:
+                    if self.global_flag_swap['verbose']:
+                        raise LoopException('Global verbose flag recursion.') from e
+                    else:
+                        self.global_flag_swap['verbose'] = True
+                self.temp_global_flag_swap = {
+                    "unicode": False,
+                    "verbose": False
+                }
+                i.rewind(i.index)
+                retry = True
+        return "".join(new_pattern)
+
+    def parse(self) -> AnyStr:
+        """Apply search template."""
+
+        if isinstance(self.search, bytes):
+            return self._parse(self.search.decode('latin-1')).encode('latin-1')
+        else:
+            return self._parse(self.search)
+
+
+class _ReplaceParser(Generic[AnyStr]):
+    """Pre-replace template."""
+
+    def __init__(self, pattern: Pattern[AnyStr], template: AnyStr, use_format: bool = False) -> None:
+        """Initialize."""
+
+        self.pattern = pattern  # type: Pattern[AnyStr]
+        self._original = template  # type: AnyStr
+        self._template = template  # type: AnyStr
+        self.use_format = use_format
+        self.end_found = False
+        self.group_slots = []  # type: list[tuple[int, tuple[int | None, int | None, Any]]]
+        self.literal_slots = []  # type: list[str]
+        self.result = []  # type: list[str]
+        self.span_stack = []  # type: list[int]
+        self.single_stack = []  # type: list[int]
+        self.literals = []  # type: list[AnyStr | None]
+        self.groups = []  # type: list[tuple[int, int]]
+        self.slot = 0
+        self.manual = False
+        self.auto = False
+        self.auto_index = 0
+        self.is_bytes = isinstance(self._original, bytes)
+
+    def parse_format_index(self, text: str) -> int | str:
+        """Parse format index."""
+
+        base = 10
+        prefix = text[1:3] if text[0] == "-" else text[:2]
+        if prefix[0:1] == "0":
+            char = prefix[-1]
+            if char == "b":
+                base = 2
+            elif char == "o":
+                base = 8
+            elif char == "x":
+                base = 16
+        try:
+            idx = int(text, base)  # type: int | str
+        except Exception:
+            idx = text
+        return idx
+
+    def get_format(self, c: str, i: _util.StringIter) -> tuple[str, list[tuple[int, Any]]]:
+        """Get format group."""
+
+        index = i.index
+        field = ''
+        value = []  # type: list[tuple[int, Any]]
+
+        try:
+            if c == '}':
+                value.append((_util.FMT_FIELD, ''))
+                value.append((_util.FMT_INDEX, -1))
+            else:
+                # Field
+                temp = []  # type: list[str]
+                if c in _LETTERS_UNDERSCORE:
+                    # Handle name
+                    temp.append(c)
+                    c = self.format_next(i)
+                    while c in _WORD:
+                        temp.append(c)
+                        c = self.format_next(i)
+                elif c in _DIGIT:
+                    # Handle group number
+                    temp.append(c)
+                    c = self.format_next(i)
+                    while c in _DIGIT:
+                        temp.append(c)
+                        c = self.format_next(i)
+
+                # Try and covert to integer index
+                field = ''.join(temp).strip()
+                try:
+                    value = [(_util.FMT_FIELD, str(int(field, 10)))]
+                except ValueError:
+                    value = [(_util.FMT_FIELD, field)]
+                    pass
+
+                if c != '[':
+                    value.append((_util.FMT_INDEX, None))
+
+                # Attributes and indexes
+                while c in ('[', '.'):
+                    if c == '[':
+                        findex = []
+                        sindex = i.index - 1
+                        c = self.format_next(i)
+                        try:
+                            while c != ']':
+                                findex.append(c)
+                                c = self.format_next(i)
+                        except StopIteration as e:
+                            raise SyntaxError(f"Unmatched '[' at {sindex - 1}") from e
+                        idx = self.parse_format_index(''.join(findex))
+                        value.append((_util.FMT_INDEX, idx))
+                        c = self.format_next(i)
+                    else:
+                        findex = []
+                        c = self.format_next(i)
+                        while c in _WORD:
+                            findex.append(c)
+                            c = self.format_next(i)
+                        value.append((_util.FMT_ATTR, ''.join(findex)))
+
+                # Conversion
+                if c == '!':
+                    c = self.format_next(i)
+                    if c not in _FMT_CONV_TYPE:
+                        raise SyntaxError(f"Invalid conversion type at {i.index - 1}!")
+                    value.append((_util.FMT_CONV, c))
+                    c = self.format_next(i)
+
+                # Format spec
+                if c == ':':
+                    fill = None  # type: str | None
+                    width = []
+                    align = None
+                    convert = None
+                    c = self.format_next(i)
+
+                    if c in ('<', '>', '^'):
+                        # Get fill and alignment
+                        align = c
+                        c = self.format_next(i)
+                        if c in ('<', '>', '^'):
+                            fill = align
+                            align = c
+                            c = self.format_next(i)
+                    elif c in _DIGIT:
+                        # Get Width
+                        fill = c
+                        c = self.format_next(i)
+                        if c in ('<', '>', '^'):
+                            align = c
+                            c = self.format_next(i)
+                        else:
+                            width.append(fill)
+                            fill = None
+                    else:
+                        fill = c
+                        c = self.format_next(i)
+                        if fill == 's' and c == '}':
+                            convert = fill
+                            fill = None
+                        if fill is not None:
+                            if c not in ('<', '>', '^'):
+                                raise SyntaxError(f'Invalid format spec char at {i.index - 1}!')
+                            align = c
+                            c = self.format_next(i)
+
+                    while c in _DIGIT:
+                        width.append(c)
+                        c = self.format_next(i)
+
+                    if not align and len(width) and width[0] == '0':
+                        raise ValueError("'=' alignment is not supported!")
+                    if align and not fill and len(width) and width[0] == '0':
+                        fill = '0'
+
+                    if c == 's':
+                        convert = c
+                        c = self.format_next(i)
+
+                    if not fill:
+                        fill = ' '
+
+                    value.append(
+                        (
+                            _util.FMT_SPEC,
+                            (
+                                fill.encode('latin-1') if self.is_bytes else fill,
+                                align,
+                                (int(''.join(width)) if width else 0),
+                                convert
+                            )
+                        )
+                    )
+
+            if c != '}':
+                raise SyntaxError(f"Unmatched '{{' at {index - 1}")
+        except StopIteration as e:
+            raise SyntaxError(f"Unmatched '{{' at {index - 1}!") from e
+
+        return field, value
+
+    def handle_format(self, t: str, i: _util.StringIter) -> None:
+        """Handle format."""
+
+        if t == '{':
+            t = self.format_next(i)
+            if t == '{':
+                self.get_single_stack()
+                self.result.append(t)
+            else:
+                field, text = self.get_format(t, i)
+                self.handle_format_group(field, text)
+        else:
+            t = self.format_next(i)
+            if t == '}':
+                self.get_single_stack()
+                self.result.append(t)
+            else:
+                raise SyntaxError(f"Unmatched '}}' at {i.index - 2}!")
+
+    def get_octal(self, c: str, i: _util.StringIter) -> str | None:
+        """Get octal."""
+
+        index = i.index
+        value = []
+        zero_count = 0
+        try:
+            if c == '0':
+                for _ in range(3):
+                    if c != '0':
+                        break
+                    value.append(c)
+                    c = next(i)
+            zero_count = len(value)
+            if zero_count < 3:
+                for _ in range(3 - zero_count):
+                    if c not in _OCTAL:
+                        break
+                    value.append(c)
+                    c = next(i)
+            i.rewind(1)
+        except StopIteration:
+            pass
+
+        octal_count = len(value)
+        if not (self.use_format and octal_count) and not (zero_count and octal_count < 3) and octal_count != 3:
+            i.rewind(i.index - index)
+            value = []
+
+        return ''.join(value) if value else None
+
+    def parse_octal(self, text: str, i: _util.StringIter) -> None:
+        """Parse octal value."""
+
+        value = int(text, 8)
+        if value > 0xFF and self.is_bytes:
+            # Re fails on octal greater than `0o377` or `0xFF`
+            raise ValueError("octal escape value outside of range 0-0o377!")
+        else:
+            single = self.get_single_stack()
+            if self.span_stack:
+                text = self.convert_case(chr(value), self.span_stack[-1])
+                value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            elif single:
+                value = ord(self.convert_case(chr(value), single))
+            if self.use_format and value in _CURLY_BRACKETS_ORD:
+                self.handle_format(chr(value), i)
+            elif value <= 0xFF:
+                self.result.append(f'\\{value:03o}')
+            else:
+                self.result.append(chr(value))
+
+    def get_named_unicode(self, i: _util.StringIter) -> str:
+        """Get named Unicode."""
+
+        index = i.index
+        value = []
+        try:
+            if next(i) != '{':
+                raise SyntaxError(f"Named Unicode missing '{{' at {i.index - 1}!")
+            c = next(i)
+            while c != '}':
+                value.append(c)
+                c = next(i)
+        except StopIteration as e:
+            raise SyntaxError(f"Unmatched '}}' at {index}!") from e
+
+        return ''.join(value)
+
+    def parse_named_unicode(self, i: _util.StringIter) -> None:
+        """Parse named Unicode."""
+
+        value = ord(_unicodedata.lookup(self.get_named_unicode(i)))
+        single = self.get_single_stack()
+        if self.span_stack:
+            text = self.convert_case(chr(value), self.span_stack[-1])
+            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+        elif single:
+            value = ord(self.convert_case(chr(value), single))
+        if self.use_format and value in _CURLY_BRACKETS_ORD:
+            self.handle_format(chr(value), i)
+        elif value <= 0xFF:
+            self.result.append(f'\\{value:03o}')
+        else:
+            self.result.append(chr(value))
+
+    def get_wide_unicode(self, i: _util.StringIter) -> str:
+        """Get narrow Unicode."""
+
+        value = []
+        for _ in range(3):
+            c = next(i)
+            if c == '0':
+                value.append(c)
+            else:  # pragma: no cover
+                raise SyntaxError(f'Invalid wide Unicode character at {i.index - 1}!')
+
+        c = next(i)
+        if c in ('0', '1'):
+            value.append(c)
+        else:  # pragma: no cover
+            raise SyntaxError(f'Invalid wide Unicode character at {i.index - 1}!')
+
+        for _ in range(4):
+            c = next(i)
+            if c.lower() in _HEX:
+                value.append(c)
+            else:  # pragma: no cover
+                raise SyntaxError(f'Invalid wide Unicode character at {i.index - 1}!')
+        return ''.join(value)
+
+    def get_narrow_unicode(self, i: _util.StringIter) -> str:
+        """Get narrow Unicode."""
+
+        value = []
+        for _ in range(4):
+            c = next(i)
+            if c.lower() in _HEX:
+                value.append(c)
+            else:  # pragma: no cover
+                raise SyntaxError(f'Invalid Unicode character at {i.index - 1}!')
+        return ''.join(value)
+
+    def parse_unicode(self, i: _util.StringIter, wide: bool = False) -> None:
+        """Parse Unicode."""
+
+        text = self.get_wide_unicode(i) if wide else self.get_narrow_unicode(i)
+        value = int(text, 16)
+        single = self.get_single_stack()
+        if self.span_stack:
+            text = self.convert_case(chr(value), self.span_stack[-1])
+            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+        elif single:
+            value = ord(self.convert_case(chr(value), single))
+        if self.use_format and value in _CURLY_BRACKETS_ORD:
+            self.handle_format(chr(value), i)
+        elif value <= 0xFF:
+            self.result.append(f'\\{value:03o}')
+        else:
+            self.result.append(chr(value))
+
+    def get_byte(self, i: _util.StringIter) -> str:
+        """Get byte."""
+
+        value = []
+        for _x in range(2):
+            c = next(i)
+            if c.lower() in _HEX:
+                value.append(c)
+            else:  # pragma: no cover
+                raise SyntaxError(f'Invalid byte character at {i.index - 1}!')
+        return ''.join(value)
+
+    def parse_bytes(self, i: _util.StringIter) -> None:
+        """Parse byte."""
+
+        value = int(self.get_byte(i), 16)
+        single = self.get_single_stack()
+        if self.span_stack:
+            text = self.convert_case(chr(value), self.span_stack[-1])
+            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+        elif single:
+            value = ord(self.convert_case(chr(value), single))
+        if self.use_format and value in _CURLY_BRACKETS_ORD:
+            self.handle_format(chr(value), i)
+        else:
+            self.result.append(f'\\{value:03o}')
+
+    def get_named_group(self, t: str, i: _util.StringIter) -> str:
+        """Get group number."""
+
+        index = i.index
+        value = [t]
+        try:
+            c = next(i)
+            if c != "<":
+                raise SyntaxError(f"Group missing '<' at {i.index - 1}!")
+            value.append(c)
+            c = next(i)
+            if c in _DIGIT:
+                value.append(c)
+                c = next(i)
+                while c != '>':
+                    if c in _DIGIT:
+                        value.append(c)
+                    c = next(i)
+                value.append(c)
+            elif c in _LETTERS_UNDERSCORE:
+                value.append(c)
+                c = next(i)
+                while c != '>':
+                    if c in _WORD:
+                        value.append(c)
+                    c = next(i)
+                value.append(c)
+            else:
+                raise SyntaxError(f"Invalid group character at {i.index - 1}!")
+        except StopIteration as e:
+            raise SyntaxError(f"Unmatched '<' at {index}!") from e
+
+        return ''.join(value)
+
+    def get_group(self, t: str, i: _util.StringIter) -> str | None:
+        """Get group number."""
+
+        value = []
+        try:
+            if t in _DIGIT and t != '0':
+                value.append(t)
+                t = next(i)
+                if t in _DIGIT:
+                    value.append(t)
+                else:
+                    i.rewind(1)
+        except StopIteration:
+            pass
+        return ''.join(value) if value else None
+
+    def format_next(self, i: _util.StringIter) -> str:
+        """Get next format char."""
+
+        c = next(i)
+        return self.format_references(next(i), i) if c == '\\' else c
+
+    def format_references(self, t: str, i: _util.StringIter) -> str:
+        """Handle format references."""
+
+        octal = self.get_octal(t, i)
+        if octal:
+            o = int(octal, 8)
+            if o > 0xFF and self.is_bytes:
+                # Re fails on octal greater than `0o377` or `0xFF`
+                raise ValueError("octal escape value outside of range 0-0o377!")
+            value = chr(o)
+        elif t in _STANDARD_ESCAPES or t == '\\':
+            value = _BACK_SLASH_TRANSLATION['\\' + t]
+        elif not self.is_bytes and t == "U":
+            value = chr(int(self.get_wide_unicode(i), 16))
+        elif not self.is_bytes and t == "u":
+            value = chr(int(self.get_narrow_unicode(i), 16))
+        elif not self.is_bytes and t == "N":
+            value = _unicodedata.lookup(self.get_named_unicode(i))
+        elif t == "x":
+            value = chr(int(self.get_byte(i), 16))
+        else:
+            i.rewind(1)
+            value = '\\'
+        return value
+
+    def reference(self, t: str, i: _util.StringIter) -> None:
+        """Handle references."""
+        octal = self.get_octal(t, i)
+        if t in _OCTAL and octal:
+            self.parse_octal(octal, i)
+        elif (t in _DIGIT or t == 'g') and not self.use_format:
+            group = self.get_group(t, i)
+            if not group:
+                group = self.get_named_group(t, i)
+            self.handle_group('\\' + group)
+        elif t in _STANDARD_ESCAPES:
+            self.get_single_stack()
+            self.result.append('\\' + t)
+        elif t == "l":
+            self.single_case(i, _LOWER)
+        elif t == "L":
+            self.span_case(i, _LOWER)
+        elif t == "c":
+            self.single_case(i, _UPPER)
+        elif t == "C":
+            self.span_case(i, _UPPER)
+        elif t == "E":
+            self.end_found = True
+        elif not self.is_bytes and t == "U":
+            self.parse_unicode(i, True)
+        elif not self.is_bytes and t == "u":
+            self.parse_unicode(i)
+        elif not self.is_bytes and t == "N":
+            self.parse_named_unicode(i)
+        elif t == "x":
+            self.parse_bytes(i)
+        elif self.use_format and t in _CURLY_BRACKETS:
+            self.result.append('\\\\')
+            self.handle_format(t, i)
+        elif self.use_format and t == 'g':
+            self.result.append('\\\\')
+            self.result.append(t)
+        else:
+            value = '\\' + t
+            self.get_single_stack()
+            if self.span_stack:
+                value = self.convert_case(value, self.span_stack[-1])
+            self.result.append(value)
+
+    def _parse_template(self, template: str) -> str:
+        """Parse template."""
+
+        self.result = [""]
+
+        i = _util.StringIter(template)
+
+        try:
+            while True:
+                t = next(i)
+                if self.use_format and t in _CURLY_BRACKETS:
+                    self.handle_format(t, i)
+                elif t == '\\':
+                    try:
+                        t = next(i)
+                        self.reference(t, i)
+                    except StopIteration:
+                        self.result.append(t)
+                        raise
+                else:
+                    self.result.append(t)
+        except StopIteration:
+            pass
+
+        if len(self.result) > 1:
+            self.literal_slots.append("".join(self.result))
+            del self.result[:]
+            self.result.append("")
+            self.slot += 1
+
+        return "".join(self.literal_slots)
+
+    def parse_template(self) -> None:
+        """Parse template."""
+
+        if isinstance(self._original, bytes):
+            self._template = self._parse_template(self._original.decode('latin-1')).encode('latin-1')
+        else:
+            self._template = self._parse_template(self._original)
+
+        if _util.PY312:
+            count = 0
+            for part in _parser.parse_template(self._template, self.pattern):
+                if isinstance(part, int):
+                    self.groups.append((count, part))
+                    self.literals.append(None)
+                elif part:
+                    self.literals.append(cast(AnyStr, part))
+                else:
+                    continue
+                count += 1
+        else:
+            self.groups, self.literals = _parser.parse_template(self._template, self.pattern)
+
+    def span_case(self, i: _util.StringIter, case: int) -> None:
+        """Uppercase or lowercase the next range of characters until end marker is found."""
+
+        # A new \L, \C or \E should pop the last in the stack.
+        if self.span_stack:
+            self.span_stack.pop()
+        if self.single_stack:
+            self.single_stack.pop()
+        self.span_stack.append(case)
+        count = len(self.span_stack)
+        self.end_found = False
+        try:
+            while not self.end_found:
+                t = next(i)
+                if self.use_format and t in _CURLY_BRACKETS:
+                    self.handle_format(t, i)
+                elif t == '\\':
+                    try:
+                        t = next(i)
+                        self.reference(t, i)
+                    except StopIteration:
+                        self.result.append(t)
+                        raise
+                else:
+                    self.result.append(self.convert_case(t, case))
+                if self.end_found or count > len(self.span_stack):
+                    self.end_found = False
+                    break
+        except StopIteration:
+            pass
+        if count == len(self.span_stack):
+            self.span_stack.pop()
+
+    def convert_case(self, value: str, case: int) -> str:
+        """Convert case."""
+
+        if self.is_bytes:
+            cased = []
+            for c in value:
+                if c in _ASCII_LETTERS:
+                    cased.append(c.lower() if case == _LOWER else c.upper())
+                else:
+                    cased.append(c)
+            return "".join(cased)
+        else:
+            return value.lower() if case == _LOWER else value.upper()
+
+    def single_case(self, i: _util.StringIter, case: int) -> None:
+        """Uppercase or lowercase the next character."""
+
+        # Pop a previous case if we have consecutive ones.
+        if self.single_stack:
+            self.single_stack.pop()
+        self.single_stack.append(case)
+        try:
+            t = next(i)
+            if self.use_format and t in _CURLY_BRACKETS:
+                self.handle_format(t, i)
+            elif t == '\\':
+                try:
+                    t = next(i)
+                    self.reference(t, i)
+                except StopIteration:
+                    self.result.append(t)
+                    raise
+            elif self.single_stack:
+                this_case = self.get_single_stack()
+                if this_case is not None:
+                    self.result.append(self.convert_case(t, this_case))
+        except StopIteration:
+            pass
+
+    def get_single_stack(self) -> int | None:
+        """Get the correct single stack item to use."""
+
+        single = None
+        while self.single_stack:
+            single = self.single_stack.pop()
+        return single
+
+    def handle_format_group(self, field: str, text: list[tuple[int, Any]]) -> None:
+        """Handle format group."""
+
+        # Handle auto incrementing group indexes
+        if field == '':
+            if self.auto:
+                field = str(self.auto_index)
+                text[0] = (_util.FMT_FIELD, field)
+                self.auto_index += 1
+            elif not self.manual and not self.auto:
+                self.auto = True
+                field = str(self.auto_index)
+                text[0] = (_util.FMT_FIELD, field)
+                self.auto_index += 1
+            else:
+                raise ValueError("Cannot switch to auto format during manual format!")
+        elif not self.manual and not self.auto:
+            self.manual = True
+        elif not self.manual:
+            raise ValueError("Cannot switch to manual format during auto format!")
+
+        self.handle_group(field, tuple(text), True)
+
+    def handle_group(
+        self,
+        text: str,
+        capture: tuple[tuple[int, Any], ...] | None = None,
+        is_format: bool = False
+    ) -> None:
+        """Handle groups."""
+
+        if len(self.result) > 1:
+            self.literal_slots.append("".join(self.result))
+            if is_format:
+                self.literal_slots.extend(["\\g<", text, ">"])
+            else:
+                self.literal_slots.append(text)
+            del self.result[:]
+            self.result.append("")
+            self.slot += 1
+        elif is_format:
+            self.literal_slots.extend(["\\g<", text, ">"])
+        else:
+            self.literal_slots.append(text)
+
+        self.group_slots.append(
+            (
+                self.slot,
+                (
+                    (self.span_stack[-1] if self.span_stack else None),
+                    self.get_single_stack(),
+                    (() if self.is_bytes else '') if capture is None else capture
+                )
+            )
+        )
+        self.slot += 1
+
+    def get_base_template(self) -> AnyStr:
+        """Return the unmodified template before expansion."""
+
+        return self._original
+
+    def parse(self) -> ReplaceTemplate[AnyStr]:
+        """Parse template."""
+
+        if not isinstance(self.pattern.pattern, type(self._original)):
+            raise TypeError('Pattern string type must match replace template string type!')
+
+        self.parse_template()
+
+        return ReplaceTemplate(
+            tuple(self.groups),
+            tuple(self.group_slots),
+            tuple(self.literals),
+            hash(self.pattern),
+            self.use_format,
+            self.is_bytes
+        )
+
+
+class ReplaceTemplate(_util.Immutable, Generic[AnyStr]):
+    """Replacement template expander."""
+
+    __slots__ = ("groups", "group_slots", "literals", "pattern_hash", "use_format", "_hash", "_bytes")
+
+    groups: tuple[tuple[int, int], ...]
+    group_slots: tuple[tuple[int, tuple[int | None, int | None, Any]], ...]
+    literals: tuple[AnyStr | None, ...]
+    pattern_hash: int
+    use_format: bool
+    _hash: int
+    _bytes: bool
+
+    def __init__(
+        self,
+        groups: tuple[tuple[int, int], ...],
+        group_slots: tuple[tuple[int, tuple[int | None, int | None, Any]], ...],
+        literals: tuple[AnyStr | None, ...],
+        pattern_hash: int,
+        use_format: bool,
+        is_bytes: bool
+    ) -> None:
+        """Initialize."""
+
+        super().__init__(
+            use_format=use_format,
+            groups=groups,
+            group_slots=group_slots,
+            literals=literals,
+            pattern_hash=pattern_hash,
+            _bytes=is_bytes,
+            _hash=hash(
+                (
+                    type(self),
+                    groups, group_slots, literals,
+                    pattern_hash, use_format, is_bytes
+                )
+            )
+        )
+
+    def __call__(self, m: Match[AnyStr] | None) -> AnyStr:
+        """Call."""
+
+        return self.expand(m)
+
+    def __hash__(self) -> int:
+        """Hash."""
+
+        return self._hash
+
+    def __eq__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            isinstance(other, ReplaceTemplate) and
+            self.groups == other.groups and
+            self.group_slots == other.group_slots and
+            self.literals == other.literals and
+            self.pattern_hash == other.pattern_hash and
+            self.use_format == other.use_format and
+            self._bytes == other._bytes
+        )
+
+    def __ne__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            not isinstance(other, ReplaceTemplate) or
+            self.groups != other.groups or
+            self.group_slots != other.group_slots or
+            self.literals != other.literals or
+            self.pattern_hash != other.pattern_hash or
+            self.use_format != other.use_format or
+            self._bytes != self._bytes
+        )
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation."""
+
+        return "{}.{}({!r}, {!r}, {!r}, {!r}, {!r})".format(
+            self.__module__, self.__class__.__name__,
+            self.groups, self.group_slots, self.literals,
+            self.pattern_hash, self.use_format
+        )
+
+    def _get_group_index(self, index: int) -> int:
+        """Find and return the appropriate group index."""
+
+        g_index = 0
+        for group in self.groups:
+            if group[0] == index:
+                g_index = group[1]
+                break
+        return g_index
+
+    def _get_group_attributes(self, index: int) -> tuple[int | None, int | None, Any]:
+        """Find and return the appropriate group case."""
+
+        g_case = (None, None, -1)  # type: tuple[int | None, int | None, Any]
+        for group in self.group_slots:
+            if group[0] == index:
+                g_case = group[1]
+                break
+        return g_case
+
+    def expand(self, m: Match[AnyStr] | None) -> AnyStr:
+        """Using the template, expand the string."""
+
+        if m is None:
+            raise ValueError("Match is None!")
+
+        sep = m.string[:0]
+        if not isinstance(sep, bytes if self._bytes else str):
+            raise TypeError('Match string type does not match expander string type!')
+        text = []
+        # Expand string
+        for x in range(0, len(self.literals)):
+            index = x
+            l = self.literals[x]
+            if l is None:
+                g_index = self._get_group_index(index)
+                span_case, single_case, capture = self._get_group_attributes(index)
+                if not self.use_format:
+                    # Non format replace
+                    try:
+                        l = m.group(g_index)
+                        if l is None:
+                            l = sep
+                    except IndexError as e:  # pragma: no cover
+                        raise IndexError(f"'{g_index}' is out of range!") from e
+                else:
+                    # String format replace
+                    try:
+                        obj = m.group(g_index)
+                    except IndexError as e:  # pragma: no cover
+                        raise IndexError(f"'{g_index}' is out of range!") from e
+                    l = _util.format_captures(
+                        [] if obj is None else [obj],
+                        capture,
+                        _util._to_bstr if isinstance(sep, bytes) else _util._to_str,
+                        sep
+                    )
+                if span_case is not None:
+                    if span_case == _LOWER:
+                        l = l.lower()
+                    else:
+                        l = l.upper()
+                if single_case is not None:
+                    if single_case == _LOWER:
+                        l = l[0:1].lower() + l[1:]
+                    else:
+                        l = l[0:1].upper() + l[1:]
+            text.append(l)
+
+        return sep.join(text)
+
+
+def _pickle(r):  # type: ignore[no-untyped-def]
+    """Pickle."""
+
+    return ReplaceTemplate, (r.groups, r.group_slots, r.literals, r.pattern_hash, r.use_format, r._bytes)
+
+
+_copyreg.pickle(ReplaceTemplate, _pickle)